;		NES KUNG FU GAME STATE MACHINE
;
;COPYRIGHT 1990 BY DANIEL LAWTON, ALL RIGHTS RESERVED.
;LAST UPDATE STARTED ON 9/15/90

;			HOW THIS STATE MACHINE WORKS:
;
;TO ASSEMBLE, YOU JUST RUN A65 KUNGFU.  THE KUNGFU.ASM FILE "INCLUDES"
;ALL NECESSARY FILES.  THESE FILES ARE KUNGSUBS.ASM, KUNGTAB.ASM,
;YOURBACK.ASM, YOURCODE.ASM, YOURSND.ASM, AND DRAWDATA.ASM.  
;YOURBACK AND DRAWDATA ARE MADE AUTOMATICALLY
;BY THE ND.EXE DRAWING PROGRAM.  YOURBACK HAS BACKGROUND DATA FOR THE
;SECOND ROM PAGE AND DRAWDATA HAS PALETTE/SPRITE DEFFINITIONS.  KUNGSUBS
;HAS SUBROUTINES THAT GO DIRECTLY TO THE HARDWARE.  KUNGFU IS THE STATE
;MACHINE EXECUTION MAINLINE.  KUNGTAB IS WHERE YOU PUT YOUR GAME PLAY
;DATA.  YOURCODE AND YOURSND ARE EXPLAINED AT THE TOP OF KUNGTAB.ASM.
;THE RESULT OF THE ASSEMBLY IS CODE.PRG WHICH IS LOADED WITH
;THE COLOR DREAMS DEBUGGER BOARD FOR THE NES.  IT WILL HAVE 2 32K SEGMENTS
;EACH WITH A 6 BYTE HEADER.  THE FIRST LOADS INTO PAGE 0 AND THE SECOND
;INTO PAGE 1.  YOU MUST ALSO HAVE YOUR .VID FILE WHICH IS ALSO CREATED
;AUTOMATICALLY BY THE DRAWING PROGRAM.
;
;THE STATE MACHINE USES THE DATA YOU PLACE IN KUNGTAB TO EXECUTE THE 
;GAME.  THERE ARE 3 MAIN THINGS YOU DO IN KUNGTAB.  YOU DEFINE WORLDS
;WHICH ARE BACKGROUNDS AND PALETTES.  YOU DEFINE "ENTITIES" WHICH ARE
;MOVING SPRITES.   FINALLY, YOU DEFINE THINGS IN THE BACKGROUND WHICH
;INTERACT WITH THE SPRITES.  YOU NEED TO CHECK OUT KUNGTAB.ASM AND SIMPLY
;GO THROUGH IT LINE BY LINE SETTING THE DEFINED PARAMETERS IF YOU WANT
;LEARN TO USE THE STATE MACHINE.  THIS MODULE SHOULD OPERATE TRANSPARENTLY
;TO YOU, YOU SHOULD NOT MAKE MODIFICATIONS HERE.  

;AT BOOT THIS PROGRAM SIMPLY ACTIVATES WORLD #0 AND ITS UP TO YOU TO
;DETECT RESET, INITIALIZE FLAGS, AND LOOK FOR THE START KEY. 
;CHECKOUT KUNGTAB AND BE METHODICAL ABOUT SETTING AND UNDERSTANDING 
;EACH ENTRY.

;			WORLD FLAGS DESCRIPTION
;
;THE WORLD FLAGS ARE PUT INTO KUNGTAB.ASM AT THE BOTTOM IN THE TABLES
;THAT CONTROL EACH WORLD.  EACH COMMAND OCCUPIES 6 BYTES EVEN IF THEY
;ARE NOT NEEDED IN ORDER TO SPEED UP INDEXING DURING GAME PLAY.  IN
;THE COMMAND TABLES, EACH 6 BYTE SEQUENCE MUST BE PRECEEDED BY A 1
;WORD COLUMN NUMBER ON SCREEN.  THUS EACH COMMAND THERE TAKES 8 BYTES.

;HERE IS A SAMPLE COMMAND TO LAUNCH A HERO ENTITY:
;
;	.DRW	2
;       .DB	H'F0,HEROID,9+54,H'00,-1,-1	;LAUNCH HERO

;SOMETIMES THE COMMANDS ARE FOR THINGS PASSED TO AN ENTITY SUCH AS CLIMB
;COMMANDS.  YOU CAN SET BIT H'8000 IN THE SCREEN COLUMN WORD TO DOUBLE
;THE COMMAND.  WHEN SET THIS IS THE SAME AS IF YOU PUT 2 OF THE COMMANDS
;WITH THE SECOND HAVING A COLUMN 1 MORE THAN THE FIRST:

;	.DRW	3
;	.DB     77,157,CLIMB,0,0,0
;	.DRW	4
;	.DB     77,157,CLIMB,0,0,0
;
;	IS THE SAME AS:

;	.DRW	H'8003
;	.DB     77,157,CLIMB,0,0,0
;
;DONT USE THIS WITH COMMANDS H'F0 AND ABOVE, ITS ONLY VALID FOR
;COMMANDS PASSED TO THE ENTITY AS DESCRIBED BELOW.
;
;SOME COMMANDS ARE ACTIVATED WHEN THE SCREEN SCROLLS ONTO THEM (LAUNCH ENEMY,
;SCREEN SCROLL LIMIT, ETC.) AND SOME ARE ACTIVATED WHEN AN ENTITY STEPS
;ONTO THEM.  THE SCREEN SCROLL COMMANDS ARE SCANNED FOR WHEN A SCREEN
;FIRST COMES UP.  THERE AFTER, SCROLLING THE SCREEN CAUSES ANY NEW COMMANDS
;THAT SCROLL IN TO BE USED.  THEY ARE ONLY CONSIDERED SCROLLED ONTO WHEN
;PIXEL 0 OF THAT COLUMN IS COMPLETELY VISIBLE (THIS IS TO MAKE SURE THAT
;LAUNCHED ENTITIES CAN BE PLACED DOWN ACCURATELY TO THE PIXEL LEVEL).
;
;ENTITY ACTIVATED COMMANDS ARE IGNORED UNTIL
;AN ENTITY STEPS INTO THEIR COLUMN AND ROW RANGE.  THERE IS ONLY 1
;ENTITY ACTIVATED COMMAND, IT REPORTS TO A GENERIC ANIMATION/MOVEMENT 
;FUNCTION IN THE ENTITIES TABLE AND THAT MOVEMENT ROUTINE DECIDES WHAT
;TO DO ABOUT IT (A DOOR, CLIMB, ETC).  THE ENTITY HAS A "HOT SPOT"
;THAT IS USED TO DECIDED WHEN HE FALLS INTO THE ROW AND COLUMN RANGE 
;OF THE COMMAND.  AS STATED ABOVE, YOU CAN DOUBLE THESE COMMANDS BY
;SETTING BIT H'8000 IN THE COLUMN WORD SPECIFICATION.

;HERE IS A "PICTURE" SHOWING THE "HOT SPOT" OF THE ENTITY 
;(Xs REPRESENT ENTITY):
;
;
;           XXX	
;	    XXX	    
;	    XxX	
;	     ^
;	     ONLY THE CENTER BOTTOM POINT IS ACTIVE 

;THE FIRST BYTE OF EACH COMMAND DETERMINES WHAT THE COMMAND DOES.
;THE REMAINING BYTES (5 MORE) ARE SPECIFIC TO THE COMMAND.  HERE
;ARE THE COMMANDS:

;00 = NO ACTION OR TARGET.  MUST REMAIN 0.  USED INTERNALLY.
;
;01 TO H'EF = WORLD EVENT COMMAND.  
;		COMMANDS IN THIS RANGE ARE ACTUALLY TOP OF SCREEN ROW
;		SPECIFICATIONS FOR A SCREEN RANGE IN WHICH YOUR ENTITY
;		WILL BE NOTIFIED IF IT STEPS INTO THAT RANGE.  IN ORDER
;		TO SAVE PROCESSOR POWER, EACH ENTITY HAS A BIT TO DETERMINE
;		IF IT WILL CHECK FOR COMMANDS OR NOT CHECK.  WHEN THE BIT
;		IS SET (IN ENTITYTAB) THEN THE ENTITY WILL BE TOLD WHEN
;		HE WALKS ONTO THIS COMMAND.   HE IS CONSIDERED HAVING 
;		WALKED ONTO THE COMMAND IF HIS HOTSPOT (HIS BOTTOMMOST PIXEL
;		IN THE CENTER OF HIS BODY) FALLS BETWEEN THE TOP ROW SPECIFIED
;		IN THE FIRST BYTE AND THE BOTTOM ROW SPECIFIED IN THE 
;		SECOND BYTE.  SOME OF THE REMAINING BYTES ARE PASSED TO
;		YOUR MOVEMENT CODE IN KUNGTAB.ASM TO DECIDE WHAT THIS
;		COMMAND IS SUPPOSED TO DO.  SOME EQUATES HAVE BEEN
;		DEFINED FOR THE FIRST OF THE PASSED BYTES IN ORDER TO
;		ESTABLISH A STANDARD FOR DOORS OR CLIMBING BUT ACTUALLY
;		YOU CAN USE ANY VALUE FROM 0-255 FOR EITHER OF THE COMMAND
;		BYTES AND YOUR CODE CAN DECIDE B]ASED ON THE VALUE OR
;		ON THE EQUATES PROVIDED.  
;
;		YOU CAN TEST IN YOUR CODE TO SEE IF THE UP OR DOWN ARROW
;		KEY HAS BEEN PRESSED.  THE STATE MACHINE WILL RE-REPORT
;		THE COLUMN TO YOU IF THE UP OR DOWN KEY IS PRESSED WHILE YOU
;		ARE ON THE COLUMN EVEN IF THE COLUMN HAS ALREADY BEEN
;		REPORTED.  THIS IS DONE SO YOU CAN HAVE PIPES LIKE IN
;		SUPER MARIO OR CAN HAVE DOORS THAT YOU HAVE TO PRESS UP
;		TO GO INTO.  BUT FOR THIS TYPE OF USAGE ITS BEST TO USE
;		THE QUALIFYING BYTE FIELDS TO KEEP THE COMMAND FROM BEING
;		REPORTED IF THE CORRECT KEYS ARE NOT PRESSED.  OTHERWISE YOUR
;		HERO WILL "STAGGER" AS HE RUNS OVER THE COMMANDS AND USES
;		UP PROCESSOR POWER ONLY TO DECIDE THE UP KEY WAS NOT PRESSED.
;		IF YOU USE THE QUALIFYING BYTES HERE'S HOW THEY WORK:  THE
;		"AND" MASK IS ANDED TO THE JOYSTICK BITS AS USED IN THE
;		<BUTTON> COMMAND DESCRIBED IN KUNGTAB.  THEN THE RESULTING
;		VALUE IS 
COMPARED TO THE MATCH VALUE.  THE COMMAND IS ONLY
;		REPORTED IF THERE IS A MATCH.  SET BOTH TO 0 TO DISABLE THIS
;		FUNCTION.

;
;		HERE IS THE FULL COMMAND FORMAT:
;		 1 BYTE TOP TILE (PIXELS\8) ROW (1 ORIGIN!)
;		 1 BYTE BOTTOM ROW (1 ORIGIN!)
;		 1 BYTE TO PASS TO THE MOVEMENT CODE AS PARAM1 (WORLDCMD).
;		 1 BYTE TO PASS TO THE MOVEMENT CODE AS PARAM2.
;		 1 BYTE JOYSTICK BITS TO MATCH (IF ENTITY IS ATTACHED TO
;			A JOYSTICK).   USE 0 TO DISABLE THIS FUNCTION.
;		 1 BYTE AND MASK TO APPLY TO JOYSTICK BITS BEFORE COMPARING
;			TO THE MATCH VALUE.  USE 0 TO DISABLE THIS FUNCTION.
;
;		HERE ARE SOME EQUATES RECOMMENDED TO BE PLACED IN PARAM1
;		AS A SIGNAL OF WHAT YOU WANT.  YOU WOULD PUT THE QUALIFIER
;		IN PARAM2 (WORLD TO GO TO, ETC.):
;F0 = LAUNCH ENTITY.  
;		          THIS COMMAND WILL LAUNCH THE ENEMY TYPE YOU SPECIFY
;			  FROM THE LOCATION YOU SPECIFY.  IT IS ILLEGAL
;			  TO LAUNCH AN ENEMY FROM COLUMN 65535.
;
;	             	BYTE 1 = ENEMY NUMBER FROM ENTITYTAB
;			BYTE 2 = TEXT ROW TO LAUNCH FROM (USES TEXT COL
;			  	 OF COMMAND LOCATION).
;			BYTE 3 = PLACED INTO PARAM2 OF THE ENTITY. NOTE:
;				 ENTITIES LAUNCHED FROM OTHER ENTITIES HAVE
;				 -1 PLACED HERE SINCE THERE IS NO BYTE 3.
;			BYTE 4 = -1 TO LAUNCH ENTITY IMMEDIATLY WHEN HIS
;				 LAUNCH COLUMN COMES FULLY ONTO SCREEN.
;				 ANY OTHER VALUE IS THE COLUMN ON SCREEN
;			         TO LAUNCH HIM FROM WHEN HIS ORIGIN COLUMN
;				 REACHES THAT POINT.  FOR EXAMPLE, SET THIS
;				 TO 16.  THEN AS THE WORLD SCROLLS HE WILL
;				 POP UP IN THE CENTER OF THE SCREEN.  WHILE
;				 WAITING TO COME TO THE CORRECT POINT HE WILL
;				 BE IN "SLEEP" MODE.  THIS MODE TAKES UP
;				 AN ENTITY SLOT BUT THE ENTITY ITSELF DOES
;				 NOT EXECUTE CODE AND IS NOT VISIBLE.
;			BYTE 5 = PERMANENT MEMORY INDEX TO USE FOR THIS ENTITY.
;				 USED IN CONJUNCTION WITH THE ENMEMORY
;				 COMMAND.  SET THIS TO -1 TO LAUNCH THE 
;				 ENTITY EVERYTIME THE COMMAND SCROLLS INTO
;				 THE LAUNCH POINT.  SET TO ANY OTHER VALUE
;				 TO LAUNCH THIS ENTITY ONLY IF IT HAS NOT
;				 PREVIOUSLY BEEN KILLED.  THIS ALLOWS UP TO
;				 255 PERMANENT MEMORY ENEMIES WHO ONCE DEAD
;				 WILL NOT COME BACK.  SEE COMMAND <ENMEMORY>. 
;
;			UP TO 16 ENEMIES CAN BE LAUNCHED AT THE SAME TIME.
;			IF ALL ENEMIES ARE ALREADY ACTIVE, 
;			THIS COMMAND IS IGNORED.  
;
;F1 = LEFT WORLD LIMIT.	
;
;	WHEN THIS COMMAND IS SCROLLED INTO THE LEFTMOST SCREEN POSITION,
;	NO FURTHER LEFTWARDS SCROLLING WILL BE POSSIBLE IF THIS COMMAND
;	IS ENCOUNTERED SCROLLING LEFT.

;	THIS COMMAND IS PLACED ON THE ACTUAL BACKGROUND COLUMN AT WHICH
;	YOU WANT LEFTWARDS SCROLLING TO STOP.  IT "STICKS" TO THE LEFT
;	OF THE SCREEN WHEN HIT AND WILL NOT MOVE INTO A RIGHTWARDS 
;	VIEWABLE SCREEN POSITION (BUT THE SCROLLING TO THE RIGHT WILL NOT
;	BE AFFECTED). THE REMAINING 3 BYTES OF THIS COMMAND ARE UNUSED.
;
;F2 = RIGHT WORLD LIMIT
;
;	THIS COMMAND FUNCTIONS LIKE THE LEFT WORLD LIMIT COMMAND EXCEPT
;	THAT IT PREVENTS RIGHTWARDS MOVEMENT. THE REMAINING 3 BYTES OF 
;	THIS COMMAND ARE UNUSED.

;F3 = CONDITIONAL LEFT WORLD LIMIT
;
;	THIS COMMAND FUNCTIONS THE SAME AS F1 EXCEPT THAT THE SCREEN SCROLL
;	IS STOPPED LEFTWARDS ONLY IF ENTITIES MARKED AS MUST DEFEAT 
;	(BIT 04 IN ENTITYTAB FLAG BITS) ARE STILL ALIVE (ON SCREEN).

;F4 = CONDITIONAL RIGHT WORLD LIMIT
;
;	THIS COMMAND FUNCTIONS THE SAME AS F2 EXCEPT THAT THE SCREEN SCROLL
;	IS STOPPED RIGHTWARDS ONLY IF ENTITIES MARKED AS MUST DEFEAT 
;	(BIT 04 IN ENTITYTAB FLAG BITS) ARE STILL ALIVE (ON SCREEN).
;
;

;**********************************************************************
;		TROUBLES?  CONSULT THIS CHART...
;
;PROCESSOR POWER TROUBLES:
;1. MAKE SURE THERE ARENT TOO MANY CONSTANTLY REARMING OR PERMANENTLY
;   REARMED ENTITIES ON SCREEN.   THE ATTACKS TAKE LOTS OF POWER.  WATCH
;   OUT FOR TIGHT RANGE LOOPS ON LOTS OF ENTITIES AT THE SAME TIME.
;
;ATTACK DOESN'T SEEM TO BE ARMED:
;1. ONCE ARMED, AN ATTACK ONLY TRIGGERS ONCE UNTIL REARMED.  IF AT THE
;   TIME OF TRIGGER IT HITS NO ONE, DON'T EXPECT IT TO STAY "ARMED"
;   UNTIL IT HURTS SOMEONE.  ITS ONLY ARMED FOR 1 CYCLE OF THE ANIMATION
;   TO THE PROPER FRAME THEN IT DISARMS WHETHER IT HITS SOMEONE OR NOT.
;
;PROGRAM CRASHES WILDLY:
;1. CHECK FOR .DBs WHEN THERE SHOULD BE .DRWs AND VICE VERSA.  TRY THESE:
;		SKIPS WITH .DBs FOR DESTINATION
;		.DRWs WITH THE X AND Y OF THE RANGE COMMAND
;2. CHECK FOR TABLE COMMANDS WITH NOT ENOUGH ENTRIES FOR THE REGISTER
;   VALUE.  TRY STORING THE REGISTER IN SOME UNUSED COMMON DATA AREA
;   RAM JUST BEFORE THE TABLE COMMAND.  THEN IF IT CRASHES YOU CAN LOOK
;   AT THE LAST VALUE WITH THE DEBUGGER.  CHECK KUNGFU.LST FOR COMMONDATA
;   TO SEE WHERE THE BASE IS AND THEN ADD YOUR BYTE LOCATION.
;3. MAKE SURE THAT YOU HAVEN'T OVERFLOWED PROGRAM OR BACKGROUND MEMORY.
;THE ASSEMBLER WON'T WARN YOU.  CHECK CODE.SEG (OR OBJ) TO MAKE SURE THAT 
;THE TOP ORG ISN'T OVERFLOWED BY THE BOTTOM ONE.  CHECK MEMORY.SEG
;AT THE BOTTOM AND GO UP UNTIL YOU FIND THE DISCONTINUITY IN THE 
;ORGS.  THATS WHERE YOU BACKGROUND DATA MIGHT OVERFLOW INTO THE CODE
;IN THE SECOND PAGE.
;
;ENTITIES DISAPEAR WHILE ACTIVE FOR NO APPARENT REASON:
;
;1. IF YOU HAVE ENTITIES WHOS ANIMATIONS TAKE UP DIFFERENT NUMBERS OF
;SPRITES, ITS POSSIBLE THAT DURING THE SMOOTH ANIMATION CHANGE OF AN
;ACTIVE ENTITY A CONDITION COMES UP WHERE THERE AREN'T ENOUGH SPRITES
;TO BRING IN THE NEW ANIMATION.  AVOID MAKING ANIMATIONS WHICH TAKE UP
;DIFFERENT AMOUNTS OF SPRITES IF YOU KNOW THAT THE WORLD WHERE THEY ARE
;GOING TO BE USED WILL HAVE FEW SPRITES AVAILABLE.  FOR INSTANCE, IN
;CHALLENGE OF THE DRAGON THE MONGOLIAN GIANT WHO MAKES ROCKS COME CRASHING
;DOWN WOULD HAVE PROBLEMS IF HIS ANIMATIONS DIFFERED IN SIZE BECAUSE HE
;CREATES AS MANY ROCKS AS THERE ARE SPRITES AVAILABLE.  THIS USED TO
;CAUSE HIM TO DISAPPEAR BECAUSE HIS HITTING ANIMATION WAS NOT AS WIDE AS
;HIS WALKING ANIMATION.  THE HITTING MADE ALL SPRITES GET USED UP FOR
;ROCKS AND THEN HE COULDN'T BRING IN HIS WALK. THE SOLUTION WAS TO PAD HIS
;WALK OUT WITH BLANKS BUT IT MADE IT EASIER TO SWORD ATTACK HIM.
;
;HERO GETS INTO JUMP POSITION WHEN HE WASN'T JUMPING OR GETS STUCK IN IT:
;
;1. IF YOUR JUMP CODE STARTS BY CHECKING FOR STANDING AND DOES A RESUME IF
;YOU HERO ISN'T STANDING, YOU MUST HAVE -1 FOR THE ANIMATION OR ELSE YOU
;WILL ALWAYS GET THE JUMP IMAGE REGARDLESS IF YOU ARE JUMPING AND THE
;CODE THAT GETS RESUMED WON'T GET RID OF IT.  USE -1 AND THEN SEQUENCE
;THE PICTURE AFTER YOUR CODE DECIDES ITS OK TO JUMP.
;
;ENTITIES MADE WITH A CREATE COMMAND DON'T APPEAR:
;
;1. IF YOU CREATE THEM NEAR THE LEFT OR RIGHT OF THE SCREEN THEY MIGHT SCROLL
;OFF BEFORE THEY GET A CHANCE TO MOVE MORE INTO THE CENTER OF THE SCREEN.
;
;ENTITIES GET STUCK IN SOLIDS AFTER BEING RESTORED FROM A VIRTUALIZATION:
;
;1. IF THE ENTITY HAS A DIFFERENT HEIGHT ANIMATION AND GETS VIRTUALIZED
; WITH THE SHORTER ONE WHILE STANDING, THEN WHEN HE IS RESTORED THE WAKEUP
; ANIMATION IS USED.  IF ITS TALLER, HE WILL BE STUCK.  MAKE THE WAKEUP
; USE THE SHORTEST ONE INSTEAD.
;
;ENTITIES SHIFT ON SCREEN WHEN THEY GO IN OR OUT OF VIRTUALIZATION:
;
;1. IF YOU USE MOVEOVER AT WAKEUP, REMEMBER THAT RETURN FROM VIRTUALIZATION
;   WILL DO THE MOVEOVER AGAIN UNLESS YOU TAKE STEPS TO STOP IT.
;***********************************************************
;
;	 CONTROL DATA INFORMATION FOR THE GAME STATE MACHINE.
;
;THIS ASSEMBLY CONTAINS THE SOUNDS, POINT TABLES, MUSIC, AND CONTROL
;DATA TABLES FOR THE NES UNIVERSAL QUEST GAME STATE MACHINE.
;
;THE BACKGROUND DATA SHOULD BE IN <<< YOURBACK.ASM >>>
;(THE DRAWING PROGRAM ND.EXE WILL MAKE THIS FILE).
;
;THE SPRITE AND PALETTE DATA SHOULD BE IN <<< DRAWDATA.ASM >>>
; (THE DRAWING PROGRAM ND.EXE WILL MAKE THIS FILE).
;
;THE SOUND INFO CAN BE IN THIS FILE OR IN A FILE CALLED <<< YOURSND.ASM. >>>
;IF YOU PUT IT INTO YOURSND.ASM IT WILL GO INTO THE SECOND ROM PAGE.
;THAT SHOULD BE BEST SINCE THIS STATE MACHINE SUPPORTS STRIPIZING
;YOUR BACKGROUNDS AND SHOULD LEAVE YOU WITH ROOM IN THE SECOND PAGE.
;YOU MUST HAVE THIS FILE EVEN IF ITS EMPTY.
;
;CODE FOR YOUR ENTITIES MAY BE PUT INTO THE FILE <<< YOURCODE.ASM >>> IF
;YOU WANT TO PUT IT INTO THE SECOND PAGE.   YOU MUST HAVE YOURCODE
;EVEN IF ITS EMPTY.

;
;**************************************************************************

;**************************************************************************
;			HINTS AND GOOD IDEAS
;
;PRIZE MAKING: YOU COULD MAKE PRIZES ATTACK THE HERO AND HAVE THE HERO
;IGNORE THE ATTACK AND HAVE THE PRIZE INCREMENT WHATEVER PRIZE COUNT
;BUT THIS MAKES YOUR HERO HAVE TO USE A -1 ANIMATION OR ELSE HE WOULD
;SKIP INTO HIS HURT ANIMATION.  HERE'S A BETTER WAY:  MAKE YOUR PRIZES
;TARGET THE HERO.  THEN USE A RANGE COMMAND INSIDE THE PRIZE'S CODE
;LOOP AND MAKE THE PRIZE DO EVERYTHING WITHOUT THE HERO EVER KNOWING
;ABOUT IT.  YOU MIGHT HAVE TO MAKE A MAILBOX IN COMMON DATA RAM FOR
;SOME CASES.
;
;SHOWING HEALTH AND MEN LEFT:  MAKE AN ENTITY THAT DOES THIS RUNNING
;HALF FREQUENCY.  THEN WHEN YOU WANT AN UPDATE, JUST USE THE CREATE COMMAND
;TO LAUNCH HIM.  HE SHOULD DIE BY HIMSELF WHEN DONE.  THE ONLY PROBLEM WITH
;THIS TECHNIQUE IS THAT YOU MUST MAKE SURE A SLOT IS ALWAYS AVAILABLE FOR
;THIS OR YOU STATUS BAR MIGHT NOT GET UPDATED.
;**************************************************************************

;**************************************************************************
;
;		ANIMATION/MOVEMENT TABLE FORMAT
;
;**************************************************************************

;THE ANIMATION/MOVEMENT LIST SPECIFIES THE ANIMATION AND MOVEMENT TABLE
;TO USE FOR THE WAKEUP ANIMATION AND FOR ANY OTHER MODES THAT THE 
;ENTITY CAN ENTER INTO. YOU DON'T HAVE TO HAVE A UNIQUE ANIMATION FOR EACH 
;ENTRY, FOR INSTANCE, THE WAKE UP CAN BE THE SAME AS THE STANDING AND ANY
;OF THE ATTACKS MAY DUPLICATE ANOTHER ATTACK.  THERE IS ONE MAJOR RULE
;FOR THE ARTISTS TO REMEMBER!!!! THE WAKE UP ANIMATION MUST CONTAIN
;THE BIGGEST WIDTH OF THE ANIMATION SEQUENCES.  THE WIDTH MAY VARY
;FROM THEN ON BUT THE HEIGHT CANNOT.  

;REMEMBER THAT THE HERO IS JUST A SPECIAL CASE OF AN ENTITY WHOS
;MOVEMENTS ARE TIED TO THE JOYSTICK.  ALSO, BULLETS ARE SIMPLY
;ENEMIES LAUNCHED FROM ANOTHER ENTITY.  PLATFORMS ARE ALSO JUST
;ENTITIES AS ARE SPECIAL EFFECTS.  ANY SPRITE ON THE SCREEN IS
;JUST ANOTHER CASE OF AN ENTITY WITH A MOVEMENT TABLE.

;WHEN AN ANIMATION IS ACTIVATED, THE INIT OPTIONS FLAG IS USED.
;HERE IS THE FORMAT FOR THE  INIT OPTIONS FLAG BYTE:

;	H'07 = 3 BITS USED WITH THE ALIGN ON X OR Y BITS.  GIVES ALIGN VALUE.
;		TYPICAL VALUE IS 2.  ITS THE COUNT TO SHIFT X LOCATION RIGHT
;		AND RESULT IS USED TO PICK A FRAME.
;	H'08 = UNUSED.  SET TO 0.
;	H'10 = TRUE IF HERO ANIMATION ALIGNS TO Y AXIS
;	H'20 = TRUE IF HERO ANIMATION ALIGNS TO X AXIS
;	H'40 = TRUE IF ANIMATION SHOULD AUTOFREEZE (RUN TO END AND STOP)
;	H'80 = UNUSED. SET TO 0.

;WHEN ENEMIES AND HEROS "ATTACK" WITH EACH OTHER, THE DAMAGE FLAGS
;ARE USED TO QUALIFY IF DAMAGE IS TAKEN BY THE ONE ATTACKED.
;THERE ARE 3 DAMAGE FLAG BYTES.  HERE ARE THEIR FORMATS:

;DAMAGE FLAG #1 = 1 BYTE FRAME # ON WHICH ATTACK IS ACTIVE. SET IT TO -1
;		TO DISABLE ATTACKS.  FOR WALKING, STANDING, ETC.
;		YOU WOULD TYPICALLY DISABLE IT WITH -1. NOTE THAT
;		THE ANIMATION WILL BE CHECKED AT A FREQUENCY OF 3
;		RELATIVE TO THE ANIMATION SO YOUR ANIMATION MUST
;		RUN SLOWER THAN THIS OR YOU MIGHT MISS THE FRAME
;		ON WHICH THE ATTACK IS ACTIVE.  THE ATTACK IS "ARMED"
;		WHEN THE ANIMATION IS INITIALIZED AND TRIGGERS WHEN
;		THIS FRAME NUMBER IS LESS THAN OR EQUAL TO THE CURRENT
;		FRAME #.  AN ATTACK WILL ONLY TRIGGER 1 TIME.  USE COMMAND
;		A6 IF YOU NEED MORE TRIGGERS.
;
;		FOR SPRITES WHICH ARE NOT ANIMATIONS, USE FRAME #0.
;
;		FOR A PERMANENTLY ARMED ATTACK (TAKES LOTS OF PROCESSOR
;		POWER!), USE -2.
;
;DAMAGE FLAG #2 = 1 BYTE HOTSPOT FLAG.  THIS BYTE SPECIFIES THE LOCATION
;		  IN SPACE RELATIVE TO THE ENTITY WHICH IS CONSIDERED
;		  THE ATTACKED AREA WHEN AN ATTACK IS COMPLETED.  THE
;		  DIRECTION THE ENTITY FACES IS THE DIRECTION THAT
;		  YOUR FLAG WILL BE USED. IT IS A NIBBLE ORIENTED FLAG:
;		    BITS 0F = (DISTANCE/2) FROM CENTER OF SPRITE.
;		    BITS F0 = (DISTANCE/4) FROM TOP OF SPRITE.
;
;DAMAGE FLAG #3 = 1 BYTE DAMAGE BITS:
;		    BITS 07 = AMOUNT OF DAMAGE TO APPLY TO HERO OR ENTITY
;			      WHEN THIS ATTACK HITS HIM.  SET 
;			      TO 0 IF DESIRED, THEN ONLY THE HURT SEQUENCE
;			      WILL BE ACTIVATED BUT NO DAMAGE WILL OCCUR.
;			      RANGE IS 0-7 HEALTHS LOST.
;		    BIT  08 = SET TO SELECT HURT NUMBERS 16-31.
;		    BITS F0 = HURT # TO REPORT TO THE ENTITY THAT WAS HURT
;			      BY THIS ATTACK.  ALLOWS HURT # 0-15. SET BIT
;			      08 TO REPORT HURT NUMBERS 16-31.
;DAMAGE FLAG #4 =   BITS 0F = X ATTACK ZONE HALF WIDTH.  THIS IS THE 
;			      DISTANCE/4 FROM THE HOTSPOT REGION WHICH 
;			      IS CONSIDERED TO BE IN THE ATTACK REGION.  
;			      THIS GIVES A TOTAL DISTANCE OF 60 WHICH 
;			      ALLOWS A 120 PIXEL WIDE ATTACK ZONE (FOR BOMBS).
;		    BITS F0 = Y ATTACK ZONE HALF WIDTH.  THIS IS THE 
;			      DISTANCE/4 FROM THE HOTSOT REGION WHICH 
;			      IS CONSIDERED TO BE IN THE ATTACK REGION.  
;			      THIS GIVES A TOTAL DISTANCE OF 60 WHICH 
;			      ALLOWS A 120 PIXEL WIDE ATTACK ZONE (FOR BOMBS).


;THE ENTRIES IN THE ANIMATION/MOVEMENT LIST WERE DESIGNED TO BE A MINIMUM
;SUBSET ACCORDING TO WHICH WERE MANDITORY (CALLED EXTERNALLY UNDER
;SOME CIRCUMSTANCES) PLUS A FEW THAT SHOULD BE COMMONLY NEEDED.
;FOR INSTANCE, WALKING AND STANDING ARE NEVER ACTIVATED EXTERNALLY
;BUT SHOULD BE COMMON ENOUGH TO BE WORTH HAVING AN ENTRY.  ATTACKING
;IS ACTIVATED EXTERNALLY FOR JOYSTICK DRIVEN ENEMIES BUT ACTUALLY
;EACH ENTITY SHOULD HAVE SEVERAL ATTACKS.  RATHER THAN INCLUDE ENTRIES
;FOR DIFFERENT ATTACKS ITS UP TO YOUR CODE TO BRANCH AND DO IT MANUALLY.

;THE SEQUENCE WAS DESIGNED TO PUT THOSE CALLED AUTOMATICALLY TOWARDS THE
;TOP OF THE LIST IN ORDER OF LIKELYHOOD THAT THEY WILL BE CALLED.  YOU
;CAN "CONTROL" YOUR WORLD SUCH THAT ENTRIES BELOW A GIVEN ONE IN THE LIST
;WILL NOT BE ACTIVATED AND THUS YOU CAN SKIP USING THE MEMORY TO SPECIFY
;THE ENTRIES BELOW THAT LAST ONE YOU NEED.  ENTRIES ARE ONLY CHECKED
;FOR VALIDITY WHEN USED.  WAKEUP IS THE ONLY ENTRY THAT MUST
;ALWAYS BE PRESENT.  AT WAKEUP, ALL INTERRUPTING STATES ARE DISABLED.
;UNLESS YOU ENABLE SOME INTERRUPT EXECUTION WILL STAY IN WAKEUP FOREVER.

;HERE ARE THE CIRCUMSTANCES UNDER WHICH THESE ANIMATION/MOVEMENT ENTRIES
;CAN BE ACTIVATED:

;1. WAKEUP IS AUTOMATIC AT ENTITY LAUNCH.
;2. HURT IS CALLED WHEN AN ATTACK HITS THIS ENTITY.
;3. FALLING IS CALLED THE FIRST TIME A GRAVITIED ENTITY WHICH WAS STANDING
;   ON SOLIDS TRAVELS IN THE DIRECTION OF GRAVITY WITHOUT A SOLID UNDER
;   IT.
;4. WORLD COMMAND IS CALLED WHEN AN ENTITY STEPS ONTO A SCREEN COLUMN
;   THAT HAS A WORLD COMMAND DEFINED AND HE IS BETWEEN THE ROWS SPECIFIED.
;5. JUMPING IS CALLED IF A JOYSTICK DRIVEN ENTITY HAS BUTTON A PRESSED.
;6. ATTACKING IS CALLED WHEN BUTTON B IS PRESSED ON A JOYSTICK ENTITY.
;7. DUCKING IS CALLED WHEN DOWN IS PRESSED ON A JOYSTICK ENTITY.  YOU SHOULD
; USUALLY CHECK IF IT WAS STANDING ON SOLIDS IN YOUR CODE.

;HERE IS THE TABLE FORMAT:

;	1 WORD WAKE UP ANIMATION OR SPRITE NAME. THIS ANIMATION IS 
;	  MANDITORY AND MUST ALSO BE THE LARGEST ANIMATION OR SPRITE
;	  IN THE SERIES SO THAT SPRITES CAN BE ALLOCATED.
;	1 WORD POINTER TO THE WAKE UP MOVEMENT LIST.  THIS LIST IS MANDITORY,
;	  DON'T TRY TO USE -1!!!!!!!!!!
;	INIT FLAG, DAMAGE FLAG #1
;	DAMAGE FLAG #2, DAMAGE FLAG #3

;	1 WORD HURT BY ATTACK.  USE -1 FOR NO CHANGE.
;	   WHEN NO CHANGE IS SPECIFIED FOR THE ANIMATION, THE INIT FLAG
;	   AND DAMAGE FLAGS ARE ALSO NOT USED.
;	1 WORD POINTER TO THE HURT MOVEMENT LIST. USE -1 FOR NO CHANGE.
;	DON'T USE NO CHANGE FOR INTERRUPT PROCESSES SINCE THEY DISABLE
;	INTS AND WILL LEAVE THEM DISABLED.  USE RESUME INSTEAD.
;	INIT FLAG, DAMAGE FLAG #1
;	DAMAGE FLAG #2, DAMAGE FLAG #3

;	1 WORD FALLING  (OR -1)
;	1 WORD POINTER TO THE FALLING MOVEMENT LIST (OR -1)
;	INIT FLAG, DAMAGE FLAG #1
;	DAMAGE FLAG #2, DAMAGE FLAG #3

;	1 WORD WORLD COMMAND ANIMATION (ALMOST ALWAYS -1 FOR NONE)
;	1 WORD POINTER TO THE WORLD COMMAND MOVEMENT LIST (OR -1)
;	INIT FLAG, DAMAGE FLAG #1
;	DAMAGE FLAG #2, DAMAGE FLAG #3

;	1 WORD JUMPING (OR -1)
;	1 WORD POINTER TO THE JUMPING MOVEMENT LIST (OR -1)
;	INIT FLAG, DAMAGE FLAG #1
;	DAMAGE FLAG #2, DAMAGE FLAG #3

;	1 WORD ATTACKING (OR -1)
;	1 WORD POINTER TO THE ATTACKING MOVEMENT LIST (OR -1)
;	INIT FLAG, DAMAGE FLAG #1
;	DAMAGE FLAG #2, DAMAGE FLAG #3

;	1 WORD DUCKING  (OR -1)
;	1 WORD POINTER TO THE DUCKING MOVEMENT LIST (OR -1)
;	INIT FLAG, DAMAGE FLAG #1
;	DAMAGE FLAG #2, DAMAGE FLAG #3

;	1 WORD STANDING ANIMATION OR SPRITE NAME.  USE -1 FOR NO CHANGE.
;	   WHEN NO CHANGE IS SPECIFIED FOR THE ANIMATION, THE INIT FLAG
;	   AND DAMAGE FLAGS ARE ALSO NOT USED.
;	1 WORD POINTER TO THE STANDING MOVEMENT LIST.  USE -1 FOR NO CHANGE.
;	INIT FLAG, DAMAGE FLAG #1
;	DAMAGE FLAG #2, DAMAGE FLAG #3

;	1 WORD WALKING (OR -1)
;	1 WORD POINTER TO THE WALKING MOVEMENT LIST (OR -1)
;	INIT FLAG, DAMAGE FLAG #1
;	DAMAGE FLAG #2, DAMAGE FLAG #3

;**************************************************************************
;
;			COMMANDS FOR CONTROLLING THE ENTITY
;
;**************************************************************************

;FOR EACH ANIMATION ABOVE THERE IS A TABLE COMMANDS TO EXECUTE.  THE ANIMATION
;TABLE HAS THE POINTER TO THIS LIST.  YOU CAN SHARE LISTS WITH OTHER 
;ENEMIES. THE TABLE FORMAT CONSISTS OF COMMAND BYTES FOLLOWED BY 
;VARIABLE LENGTH PARAMETERS.

;ALL COMMANDS EXECUTE AT A RATE OF 60 PER SECOND UNLESS THEY CHANGE
;THE ENTITIES MOMENTUM OR ARE TIMING COMMANDS SUCH AS THE DELAY COMMAND
;OR THE FINISH COMMAND.  TO ACHEIVE THIS STEADY RATE, YOUR CLOCKPHASE
;VALUE IS USED TO DETERMINE THE NUMBER OF INSTRUCTIONS.  THUS IF YOU
;HAVE A 3 PHASE CLOCK YOU WILL EXECUTE 3 INSTRUCTIONS EVERY CYCLE.
;CHANGING TO A 2 PHASE CLOCK WILL CHANGE TO YOU 2 INSTRUCTIONS.  THIS
;ALLOWS YOU TO MAKE A CHANGE IN THE CLOCK PHASE WITHOUT SLOWING DOWN
;THE RATE AT WHICH ENTITIES EXECUTE (ALTHOUGH YOU WILL HAVE TO UPDATE
;THEIR MOMENTUM AND DELAY COMMANDS).  

;YOU CAN COUNT HOW MANY CYCLES IT WILL TAKE TO GET TO A GIVEN POINT
;BY TAKING YOU CLOCKPHASE VALUE AND COUNTING THAT MANY INSTRUCTIONS
;PER TICK UNLESS A MOMENTUM CHANGE COMMAND IS ENCOUNTERED.  WHEN
;SUCH A COMMAND IS ENCOUNTERED, THE EXECUTION IS TERMINATED FOR THAT
;CYCLE.  ALSO, SOME COMMANDS SUCH AS FINISH OR DELAY TERMINATE EXECUTION.
;THE DOCUMENTATION FOR EACH COMMAND SIGNALS IF IT IS A TERMINATING
;COMMAND.  IF YOU NEED TO SPEED UP EXECUTION OF SOME POINT IN YOUR
;CODE USE THE <INSTRUCTIONS> COMMAND.

;MOMENTUM ONCE APPLIED WILL BE USED TO MOVE THE ENTITY EVERY CLOCKPHASE
;REGARDLESS OF WHICH FLOW CONTROL COMMANDS ARE EXECUTED.  NOTE THAT
;FRICTION IS NOT APPLIED UNTIL XFCTR COMPLETE PROCESSING CYCLES ARE APPLIED
;TO THE ENTITY WITHOUT ANY CHANGES TO ITS MOMENTUM.  THIS WAS DONE TO
;ALLOW UP TO XFCTR*2 FLOW CONTROL COMMANDS IN THE STREAM BETWEEN MOMENTUM
;APPLICATIONS WITHOUT HAVING FRICTION MAKE THE MOVEMENT JUMPY.  BUT YOU
;DO NEED TO MAKE SURE MOMENTUM COMMANDS SUCH AS ADDJOYX ARE NEVER MORE
;THAN XFCTR*2 APART OR FRICTION WILL MAKE THINGS JUMPY.

;BE SURE TO USE THE EQUATES FOR THE COMMANDS AND NOT THE NUMERICAL VALUE.
;ANYTHING SHOWN IN BRACKETS ( <ACTIVATE> ) IN THE DOCUMENTATION IS AN 
;EQUATE YOU CAN USE FOR THAT FUNCTION.  THE COMMANDS ARE:

;00=	<ACTIVATE> ACTIVATE MODE.  THIS COMMAND WILL ACTIVATE ANY OF THE 
;	ANIMATION/MOVEMENT TABLE MODES.  FOR INSTANCE:  
;	ACTIVATE,EWALK WILL ACTIVATE THE WALKING ANIMATION AND MOVEMENT TABLE.  
;	SINCE ACTIVATE ONLY TAKES AN INDEX RELATIVE TO YOUR ANIMATION/MOVEMENT
;	TABLE, YOU COULD EXTEND IT BY ADDING NEW EQUATES THAT SUIT YOUR
;	OWN PURPOSES.  THEN UNLIKE THE SEQUENCE COMMAND WHICH GOES TO
;	AN ABSOLUTE MEMORY LOCATION, YOU COULD SHARE CODE BETWEEN ENTITIES
;	SINCE THE FINAL DECISION THAT RESULTS IN AN ACTIVATE WILL BE RELATIVE
;	TO THEIR OWN TABLE.  FOR INSTANCE, YOU EWALK CODE COULD END UP
;	DECIDING ON ONE OF 3 ATTACKS.  EACH ENTITY COULD USE THE SAME DECISION
;	MAKING WALKING CODE BUT THE ATTACKS COULD BE VERY DIFFERENT IF
;	THE CODE ENDED WITH DOING 1 OF 3 ACTIVATES WITH ATTACKS ADDED TO
;	THE END OF YOUR OWN LISTS.  1 BYTE FOLLOWS THIS COMMAND:
;		1 BYTE INDEX TO USE
;	USE THE FOLLOWING EQUATES TO SPECIFY THE MODE:

.EQU	EWAKE		;WAKE UP.  
.EQU	EHURT		;ENTITY HURT 
.EQU	EFALL		;FALLING
.EQU	ECMD 		;WORLD COMMAND
.EQU	EJUMP		;JUMPING
.EQU	EATTACK		;ATTACKING/SHOOTING
.EQU	EDUCK		;DUCKING (DOWN KEY PRESSED)
.EQU	ESTAND		;STANDING
.EQU	EWALK		;WALKING

;	HERE ARE SOME RECOMMENDED EXTENSIONS AND AN EQUATE YOU COULD USE:

.EQU	ENEAR		;FOR A NEAR RANGE ATTACK
.EQU	EMIDDLE		;FOR A MIDDLE RANGE ATTACK
.EQU	EFAR		;FOR A FAR RANGE ATTACK
.EQU	ECHARGE		;FOR A CHARGING ATTACK
.EQU	EPOSE		;A POSE (DELAY) BEFORE AN ATTACK
.EQU	EDODGE		;TO DODGE ATTACKS
.EQU	ESHOOT		;SHOOTING ANIMATION


;NOTES ON ACTIVATE!!! READ THIS:  

;1. IF YOU WANT A DUMB ENEMY THAT GOES INTO SOME HARD LOOP, DON'T USE
;ACTIVATE XXXX (SUCH ACTIVATE,EWAKE) BECAUSE IT TAKES TOO MUCH PROCESSOR
;POWER AND (GET THIS!) EACH TIME AN ACTIVATE IS DONE THE ENTITY "RECENTERS"
;ITSELF RELATIVE TO THE OLD SPRITE.  THIS RECENTERING MAKES IT MOVE AWAY
;FROM THE RIGHT EDGE IF ITS CENTERLINE IS PAST THE EDGE.  THIS CAN MAKE
;YOUR ENEMY REFUSE TO SCROLL OFF THE RIGHT EVEN THOUGH THE BIT TO MAKE
;HIM STAY ON SCREEN IS NOT SET IN ENTITYTAB FLAG BYTE.  SO DON'T ACTIVATE
;EXCEPT IF YOU WANT A NEW ANIMATION OR MOVEMENT LIST.

;2. IF YOU ACTIVATE AN ENTRY WITH NO ANIMATION, THE DAMAGE FLAGS ARE ALSO
;NOT RELOADED.  SO DON'T TRY TO SET UP A HOT SPOT WITHOUT RENAMING THE
;ANIMATION.

;01 = 	<RANGE> MOVE EXECUTE POINTER IF TARGET IS IN RANGE (LESS THAN  
;	DISTANCE).  THE ENTITY MUST ALSO BE FACING THE TARGET.  OLDER
;	VERSIONS SUPPORTED A CONDITION WHERE IT DIDN'T MATTER, WATCH OUT.
;	THE ENTITIES CENTERLINES ARE USED FOR THE X,
;	THE BOTTOM PIXEL ROW (ITS FOOT) IS USED FOR THE Y.
;	THIS COMMAND IS FOLLOWED BY 4 BYTES:
;	   	1 WORD NEW POINTER (USED IF TEST PASSES)
;	   	1 BYTE X RANGE IN PIXELS (USE -1 FOR DON'T CARE)
;	   	1 BYTE Y RANGE IN PIXELS (USE -1 FOR DON'T CARE)
;
;	IF YOU WANT THE RANGE REGARDLESS OF WHETHER HE IS FACING THE
;	ENEMY, USE <DISTANCE>.
;02 = 	<LEDGE> MOVE EXECUTE POINTER IF THERE IS A LEDGE ABOVE. THE CORRECTION
;	WILL BE MADE IF A SOLID LEDGE EXISTS ABOVE THE ENTITY WITHIN THE 
;	HEIGHT SPECIFIED.  3 BYTES FOLLOW THIS COMMAND:
;		1 WORD NEW POINTER
;		1 BYTE NUMBER OF ROWS TO CHECK ABOVE THE ENEMIES FEET.
;		BE CAREFUL, IT USES LOTS OF PROCESSOR POWER.
;
;03 =	<PRECIPICE> MOVE EXECUTE POINTER IF THERE IS A PRECIPICE IN THE 
;	ENEMIES FACING DIRECTION. IF A HOLE IN THE CURRENT SOLID THAT THE 
;	ENTITY IS STANDING ON EXISTS IN THE DIRECTION THE ENTITY IS 
;	TRAVELING THE EXECUTE POINTER IS MOVED. MOMENTUM FOR THE
;	ENTITY WILL BE USED TO INTERPRET THE DIRECTION, NEGATIVE VALUES
;	WILL CHECK TO THE LEFT, PLUS TO THE RIGHT.  THE CHECK FOR A PRECIPICE
;	IS MADE AS FOLLOWS; A PHANTOM COPY OF THE ENTITY IS PLACED RIGHT
;	UP AGAINST THE ENTITIES EDGE IN THE DIRECTION OF TRAVEL PLUS
;	THE AMOUNT YOU SPECIFY IN THE 3RD BYTE.  IT IS PLACED 2 PIXELS
;	DOWN.  IF NO SOLID IS FOUND IN THAT AREA THE EXECUTE POINTER IS
;	MOVED.  OTHERWISE EXECUTION CONTINUES WITH THE NEXT INSTRUCTION.
;	THE ENTITY IS NOT MOVED AS A RESULT OF THIS COMMAND.
;	3 BYTES FOLLOWS THIS COMMAND:
;		1 WORD NEW POINTER
;		1 BYTE AMOUNT TO ADD TO DIRECTION OF TRAVEL SHIFT
;
;	RECOMMENDED USAGE:  IF YOU ARE WALKING 16 OR MORE (MOMENTUM)
;	IN THE DIRECTION OF TRAVEL IT IS SUGGESTED THAT YOU USE
;	A 1 BYTE AMOUNT OF 8 AND WHEN THE PRECIPICE IS TRUE, SET THE
;	THE MOMENTUM DOWN TO 8 WALKING IN THAT DIRECTION (SO THAT YOU DON'T
;	OVERSHOOT THE PRECIPICE).  MAKE THE JUMP BASED ON A BYTE VALUE OF
;	0 HOWEVER.  THE NON-ZERO 1 BYTE AMOUNT SHOULD ONLY BE A SLOW DOWN
;	FLAG.  ITS NOT A GOOD IDEA TO DO AN ACTUAL JUMP ACROSS THE 
;	PRECIPICE BASED ON A NON-ZERO VALUE BECAUSE AN AREA SURROUNDED
;	WITH A SINGLE SOLID IN FRONT OF YOU BUT FILLED WITH NON-SOLID CAN
;	LOOK LIKE A PRECIPICE.
;04 =	<SKIP> SKIP (MOVE) EXECUTE POINTER.  THIS COMMAND IS FOLLOWED BY A 
;	1 WORD NEW OFFSET IN MEMORY TO EXECUTE FROM.  USE THE ASSEMBLERS 
;	ABILITY TO SET A WORD TO THE VALUE OF A LABEL TO FIND THE VALUE.
;05 = 	<RANDOM> MOVE EXECUTE POINTER RANDOM NUMBER IS BELOW A VALUE.  
;	THE RANDOM NUMBER GENERATOR HAS VALUES 0-255.  3 BYTES FOLLOW THIS 
;	COMMAND:
;		1 WORD NEW POINTER
;		1 BYTE RANDOM NUMBER TO BE BELOW (0-255)
;06 =	<MOMLIMIT> SET MOMENTUM LIMIT. YOU MAY ESTABLISH A NEW VALUE UP TO
;	126. 64 IS THE RECOMMENDED MAXIMUM OR ELSE YOU MIGHT BE ABLE TO
;	PASS THROUGH SINGLE HIGH SOLIDS.  2 BYTES FOLLOW THIS COMMAND:
;		1 BYTE NEW X MOMENTUM LIMIT OR <REGISTER> OR -1 = NO CHANGE
;		1 BYTE NEW Y MOMENTUM LIMIT OR <REGISTER> OR -1 = NO CHANGE
;	IF YOU WANT A MOMLIMIT OF 0 YOU MUST LOAD REGISTER.
;07 =	<DELAY> DELAY.  A DELAY SUSPENDS EXECUTION OF FURTHER COMMANDS
;	BUT DURING THIS SUSPENSION THE CURRENT MOMENTUM IS USED
;	AND GRAVITY IS APPLIED.  1 BYTE FOLLOWS THIS COMMAND:
;		1 BYTE TIME IN 1/15 SECOND INTERVALS TO DELAY.  1 IS MINIMUM.
;		   IF 0 <REGISTER> IS USED AS DELAY TIME.
;08 = 	    <ADDMOM> ADD TO MOMENTUMS.  THIS COMMAND ALLOWS YOU TO ADD A VALUE
;	TO THE X OR Y MOMENTUM.  THE SIGN OF YOUR VALUE WILL BE ADJUSTED
;	ACCORDING TO YOUR TRACKING YOU HAVE SELECTED WITH XTRACK OR YTRACK
;	IN CONJUNCTION WITH THE TARGET COMMAND.  2 BYTES FOLLOW THIS
;	COMMAND:
;		1 BYTE VALUE TO ADD TO X AXIS MOMENTUM (0=NO CHANGE).
;		1 BYTE VALUE TO ADD TO Y AXIS MOMENTUM (0=NO CHANGE).
;
;	SAMPLE USAGE:   .DB	ADDMOM,4,0    ;SLOWLY ACCELERATES X MOMENTUM.
;
;09 = 	<GRAVITY> SPECIFY GRAVITY (Y AXIS ONLY). YOU CAN TURN GRAVITY OFF WITH
;	A VALUE OF 0.  1 BYTE FOLLOWS THIS COMMAND:
;		1 BYTE NEW GRAVITY VALUE (RECOMMENDED 8 TO 32)
;			USE -1 TO PUT BACK THE DEFAULT VALUE.
;0A = 	<SOLIDSTATE> SET SOLID STATE. USE THIS COMMAND TO TEMPORARILY SUSPEND SOLID
;	CHECKING.  USUALLY USED DURING A JUMP.  THIS COMMAND WILL IMMEDIATLY
;	TURN SOLID CHECKING OFF OR ON BUT WHEN TURNING IT ON IT IS RECOMMENDED
;	TO USE THE CONDITIONAL TURN ON OR ELSE YOUR ENTITY MIGHT GET STUCK
;	IN SOLIDS.  1 BYTE FOLLOWS THIS COMMAND:
;		0 = <REGISTER> TO USE THE REGISTER'S CONTENTS
;	       -1 = <OFF> TURN OFF SOLID CHECKING
;		1 = <ON> TURN ON SOLID CHECKING
;		2 = <SAFE> TURN ON SOLID CHECKING AS SOON AS ITS SAFE (NOT 
;		    OVER SOLID).  EXECUTING THIS COMMAND WHILE THE ENTITY IS
;		    STANDING ON A SOLID RAMP ABOVE A LOWER RAMP WILL CAUSE
;		    HIM TO FALL TO THE LOWER ONE.
;		3 = <TOP> TURN ON SOLID CHECKING WHEN THE ENTITY REACHES
;			THE TOP OF A JUMP.  INTERNALLY, ITS TURNED ON
;			WHEN THE Y MOMENTUM GOES POSITIVE (INCLUDING 0).
;			MAKE SURE TO ISSUE THIS COMMAND WHEN THE MOMENTUM
;			IS NEGATIVE OR ELSE YOU MIGHT HAVE IT COME ON
;			IMMEDIATLY.
;		ANY OTHER VALUE = A NEW SOLID CHAR VALUE TO BE USED.
;
;	IF YOU WANT TO BE ABLE TO JUMP UP THROUGH ALL SOLIDS DO THE FOLLOWING:
;	 1. ISSUE AN INSTRUCTIONS,2 COMMAND, DO SOLIDSTATE,OFF FOLLOWED
;	  BY SOME UPWARDS MOMENTUM.
;	 2. WHEN YOU REACH THE TOP OF THE UPWARD MOMENTUM, DO SOLIDSTATE,SAFE.
;	 3. MAKE ABSOLUTELY SURE THAT YOU TURN SOLIDSTATE,SAFE AT THE TOP
;	  OF YOUR JUMP AND THAT ANY INTERRUPTING ROUTINE SUCH AS HURT DOES
;	  THE SAME JUST TO MAKE SURE.  ITS ALWAYS SAFE TO DO SOLIDSTATE,SAFE
;	  EVEN IF THEY WERE ON.  BUT IF YOU INTERRUPT AND YOUR CODE FAILS TO
;	  DO SAFE, YOU WILL FALL OFF SCREEN BOTTOM.
;
;	IF YOU WANT TO BE ABLE TO JUMP UP THROUGH SOME BUT NOT OTHERS
;	DO THE FOLLOWING:
;	1. ISSUE AN INSTRUCTIONS,2 COMMAND, DO SOLIDSTATE,H'XX USING
;	THE VALUE OF SOLID THAT NEVER GOES OFF.  THEN DO SOME UPWARDS
;	MOMENTUM.
;	2. WHEN YOU REACH THE TOP, DO INSTRUCTIONS,2 FOLLOWED BY 
;	SOLIDSTATE,H'xx AND THEN SOLIDSTATE,SAFE.  xx IS THE VALUE OF
;	SOLID THAT CAN BE JUMPED THROUGH.  
;	3. RULE 3 FROM ABOVE APPLIES JUST AS MUCH.
;
;0B = 	<IDENTIFY> SPECIFY ENTITY TARGET LEVEL. THIS COMMAND IS USED TO ASSIGN 
;	THIS ENTITY TO A SPECIFIC LEVEL FOR THE TARGET COMMANDS.  THERE ARE 
;	UP TO 16 LEVELS (BITS).  YOU SPECIFY A WORD VALUE HERE WITH BIT(S)
;	SET FOR THE LEVEL(S) YOU WISH TO BE ASSOCIATED WITH.  THEN
;	THE SPECIFY TARGET COMMAND IS USED BY OTHER ENTITIES TO DETECT
;	OR IGNORE THE PRESENSE OF YOUR TARGET LEVEL.  FOR INSTANCE, YOU
;	COULD ASSIGN THE HERO ENTITY TO LEVEL 0001.  THEN ENTITIES 
;	CONSIDERED "ENEMIES" COULD SPECIFY A TARGET OF 0001 OR ANY
;	OTHER VALUE WITH BIT 0001 SET AND THEY WOULD CONSIDER YOUR
;	HERO ENTITY SOMETHING TO TRACK.  AT WAKE UP, THIS VALUE IS
;	SET TO 0.   SEE UNIDENTIFY AND ADDIDENTIFY FOR SOME MORE
;	WAYS TO DO THIS.   1 WORD FOLLOWS THIS COMMAND:
;		1 WORD IDENTIFICATION LEVEL
;
;	SOME RECOMMENDED BIT POSITIONS ARE DEFINED BELOW ALONG
;	WITH EQUATE NAMES TO USE IF YOU WANT TO TARGET ONLY THEM.
;	WARNING!!!! ITS EASY TO FORGET THAT THE VALUE FOLLOWING THIS
;	COMMAND MUST BE A .DRW!!!!
;
;	0001 = <HERO0> HERO 0
;	0002 = <HERO1> HERO 1
;	0004 = <ENEMY> ENEMY WHO ATTACKS HEROS 
;	0008 = <HELPER> ENTITY WHO ATTACKS ALL BUT HEROS 
;	0010 = <BENIGN> ENEMY WHO ATTACKS ONLY THOSE WHO ATTACK HIM 
;	0020 = <HARMLESS> ATTACKABLE ANIMAL OR PERSON WHO NEVER ATTACKS
;	0040 = <KILLER> ENEMY WHO ATTACKS ANYTHING DEFINED ABOVE 
;	0080 = <DEADLY> UNKILLABLE OBJECT THAT WILL KILL IF CONTACTED (BOMB)
;	0100 = <BULLET0> HERO 0'S PROJECTILE (HERO BULLET)
;	0200 = <BULLET1> HERO 1'S PROJECTILE
;	0400 = <BULLET> ENEMIES PROJECTILE (ENEMY BULLET)
;	0800 = <PLATFORM> TRANSPORT PLATFORM
;	1000 = <HEART> HEALTH OR FUEL
;	2000 = <PRIZE> PRIZE
;	4000 = <SUPPLY> PROJECTILE SUPPLY (BULLETS, BOMBS, ETC)

;THE FOLLOWING BIT IS HARD CODED INTERNALLY TO REFER TO THE LAST ENTITY
;WHO ATTACKED YOU AND INFLICTED DAMAGE.  IT SHOULD NEVER BE USED IN
;THIS COMMAND (LEAVE IT OFF).  

;	8000 = <ASSAILANT> LAST ENTITY THAT ATTACKED THIS ENTITY

;0C = 	<TARGET> SPECIFY TARGET.  THIS COMMAND IS USED TO SPECIFY THE "TARGET"
;	LEVEL THAT THE ENTITY TRACK AND RANGE COMMANDS WILL TEST.  
;	AT WAKE UP THE TARGET IS SET TO A VALUE OF 0 (NO TARGET).  
;	1 WORD FOLLOWS THIS COMMAND AND BITS ARE SET HERE TO DETECT 
;	THE DESIRED TARGET. YOU CAN SPECIFY <REGISTER> TO USE THE
;	REGISTER'S CONTENTS FOR THE TARGET BUT THIS MEANS YOU HAVE
;	TO SETREG TO 0 TO GET A 0 TARGET.  SEE COMMAND 0B FOR TARGET
;	BIT RECOMMENDED VALUES.
;
;	FOR MORE COMPLEX TARGETING YOU CAN USE AN "OR" (|) TO ADD THEM
;	UP.  FOR INSTANCE: 
;		.DB TARGET
;		.DRW HERO0 | HERO1 | BENIGN

;0D = 	<XTRACK> SPECIFY X TARGET TRACKING. THIS COMMAND CAUSES ALL X MOMENTUM 
;	COMMANDS (WHEN EXECUTED, NOT AFTER STORAGE) TO BE SIGN CORRECTED 
;	ACCORDING TO THE DIRECTION OF THE DEFINED TARGET.  1 BYTE 
;	FOLLOWS THIS COMMAND:
;		0=<NONE> NO TRACKING AT ALL
;		1=<TOWARDS> TRACK TOWARDS TARGET (ATTEMPTS TO ALIGN THIS
;		  ENTITIES CENTER WITH THE TARGET ENTITIES CENTER)
;		2=<AWAY> TRACK AWAY FROM TARGET
;		3=<ORIGIN> TRACK TOWARDS LAUNCHING COLUMN.  IF THIS ENTITY
;		  WAS LAUNCHED BY ANOTHER ENTITY, YOU WILL GO RIGHT.
;0E = 	<YTRACK> SPECIFY Y TARGET TRACKING.  1 BYTE FOLLOWS THIS COMMAND:
;		0=<NONE> NO TRACKING AT ALL
;		1=<TOWARDS> TRACK TOWARDS TARGET (ATTEMPTS TO ALIGN THIS 
;		  ENTITIES FEET WITH THE TARGET ENTITIES FEET).
;		2=<AWAY> TRACK AWAY FROM TARGET
;		   <ORIGIN> UNAVAILABLE ON YTRACK AT THIS TIME
;0F = 	<WORLD> REQUEST WORLD (FOR WHEN A SPECIAL ENTITY IS KILLED).  1 BYTE
;	FOLLOWS THIS COMMAND:
;		1 BYTE WORLD NUMBER TO REQUEST.	 USE:
;			1-254 FOR A WORLD FROM USE_BACK
;			-1 FOR THE BOOT SCREEN
;			0 <REGISTER> FOR THE ENTITIES REGISTER.
;	 
;10 =	<JOYSTICK> GRAB JOYSTICK (#0 OR 1).  1 BYTE FOLLOWS THIS COMMAND, 
;	THE JOYSTICK NUMBER TO GRAB.   THE JOYSTICK'S MOMENTUM IS NOT 
;	ZEROED SO USE THE ZERO JOYSTICK MOMENTUM COMMAND. ONCE A JOYSTICK 
;	IS GRABBED, THIS ENTITY WILL BE UNDER ITS CONTROL AS FOLLOWS:
;	    1. 	BUTTON A WILL ACTIVATE YOUR JUMPING MODE AND THE RESUME
;		COMMAND WILL BE ENABLED.
;	    2.  BUTTON B WILL ACTIVATE YOUR ATTACKING MODE AND THE RESUME
;		COMMAND WILL BE ENABLED.
;		IT IS RECOMMENDED THAT YOU DECIDE WHICH OF THE ATTACKS IF
;		ANY TO USE OR DECIDE TO SHOOT.  THE RESUME COMMAND
;		WILL RETURN YOU TO THE EXECUTE POINT PREVIOUS TO THE
;		BUTTON PRESS (COMMAND 27).  IT IS RECOMMENDED THAT
;		YOUR ATTACK ROUTINE USE AN ANIMATION PTR OF -1 TO
;		PREVENT THE TEMPORARY SELECTION OF AN ANIMATION WHICH
;		WILL BE DISCARDED IN FAVOR OF THE ONE YOUR CODE DECIDES
;		ON (IT WOULD PUT UP SHOOT BUT YOU MIGHT DECIDE TO
;		ATTACK).
;	    3.  BUTTON DOWN WILL ACTIVATE YOUR DUCKING MODE IF YOU ARE
;		STANDING ON SOLID.  
;	    4.  WORLD COMMAND MODE WILL BE ACTIVATED IF YOU STEP ONTO A 
;		WORLD COMMAND IN THE PROPER ROWS. (STANDARD FOR ALL 
;		ENTITIES REGARDLES OF JOYSTICK IF THE BIT IS SET).
;	    5.  FALLING WILL BE ACTIVATED IF YOUR ENTITY TRAVELS IN
;		THE GRAVITY DIRECTION WITH NO SOLID UNDERNEITH.  ITS
;		THEN SHUT OFF UNTIL THE ENTITY STANDS ON SOLID AGAIN.	
;		(STANDARD FOR ALL ENTITIES REGARDLESS OF JOYSTICK CONTROL).
;	    5.  SCORE 0 WILL BE UPDATED WHEN AN ENTITY IS KILLED BY
;		THE ENTITY UNDER JOYSTICK 0s CONTROL.  SCORE 1 WILL
;		BE UPDATED WHEN AN ENTITY IS KILLED BY THE ENTITY UNDER
;		JOYSTICK 1s CONTROL.  DAMAGE TO EITHER ENTITY WILL
;		BE REFLECTED IN THE APPROPRIATE HEALTH STATUS BAR.
;		SCREEN SCROLL WILL BE ADJUSTED ACCORDING TO THE DEMANDS
;		OF THESE ENTITIES.
;
;11 =	<ADDJOYX> ADD JOYSTICK X MOMENTUM.  THE CURRENTLY STORED X AXIS
;	JOYSTICK MOMENTUM WILL BE ADDED TO YOUR ENTITIES X MOMENTUM,
;	HIS Y WILL NOT BE CHANGED.  TRACKING WILL NOT EFFECT THE VALUE,
;	THE JOYSTICK ARROW KEY PRESSED CONTROLS THE SIGN OF THE MOMENTUM.
;	THE JOYSTICK MOMENTUM WILL BE ZEROED AFTER USAGE.
;12 =	<ADDJOYY> ADD JOYSTICK Y MOMENTUM.  SAME AS ADDJOYX BUT IT
;	WORKS WITH THE Y MOMENTUM.
;13 =	<ZEROJOYX> ZERO JOYSTICK X MOMENTUM
;14 =	<ZEROJOYY> ZERO JOYSTICK Y MOMENTUM
;15 =	<BUTTON> MOVE EXECUTE POINTER IF ANY JOYSTICK BITS ARE SET.  
;	SEE <NOTBUTTON>.  3 BYTES FOLLOW THIS COMMAND:
;		1 WORD NEW POINTER
;		1 BYTE BITS TO BE SET:
;			<A_BUTTON> 
;			<B_BUTTON> 
;			<SELECT> 
;			<START> 
;			<UP> 
;			<DOWN>
;			<LEFT>
;			<RIGHT>
;EXAMPLE:	UP|DOWN  = UP OR DOWN SET.

;16 =   <SEQUENCE> ACTIVATE ANIMATION SEQUENCE AND OPTIONS.  THIS CAN BE USED
;	TO EXTEND THE SIZE OF YOUR TABLE BEYOND THE NUMBER OF ENTRIES
;	IT ALREADY CONTAINS.  
;
;	A POINTER FOLLOWS THIS COMMAND AND IT POINTS TO A STRUCTURE 
;	WITH THE SAME FORMAT AS THE STRUCTURE USED IN THE 
;	ANIMATION/MOVEMENT LIST.  YOU CAN ALSO SPECIFY <REGISTER>
;	IN WHICH CASE THE REGISTER POINTS TO THE TABLE.  2 BYTES
;	FOLLOW THIS COMMAND:
;
;	1 WORD PTR THAT POINTS TO:
;	      	1 WORD ANIMATION SEQUENCE (OR -1)
;	      	1 WORD MOVEMENT LIST (OR -1)
;		INIT FLAG, DAMAGE FLAG #1
;		DAMAGE FLAG #2, DAMAGE FLAG #3
;		DAMAGE FLAG #4, DAMAGE FLAG #5
;
;17 =	<RESUME> RESUME PREVIOUS COMMAND.  THIS COMMAND CAN BE USED TO IGNORE
;	AN EXTERNAL (JOYSTICK OR ENTITY ATTACK) REQUEST TO ACTIVATE
;	A GIVEN MODE.  IT IS IGNORED IF WE ARE NOT CURRENTLY IN A 
;	MODE REQUESTED EXTERNALLY. USE THIS IN COMBINATION WITH SETTING THE
;	ANIMATION TO -1 AND POINT YOUR MOVEMENT LIST TO A DECISION
;	MAKING DATA STREAM WHICH USES COMMAND 26 TO ACTIVATE THE DESIRED
;	ANIMATION OR MODE OR ELSE USES COMMAND 27 (THIS COMMAND) TO
;	IGNORE THE REQUEST.
;
;	RESUME WILL RESTORE THE DELAY COUNTER PRIOR TO THE INTERRUPTION
;	AND IT RESTORES THE INTERRUPT STATE PRIOR TO THE INTERRUPTS. AT
;	THE START OF ANY INTERRUPT (JUMP, ATTACK, DUCK, ETC) ALL INTERRUPTS
;	ARE DISABLED BECAUSE THERE IS ONLY 1 RESUME POINTER.  IT WOULD
;	BE A PROBLEM IF YOU CODE WERE MAKING A DECISION TO RESUME AND
;	ANOTHER INTERRUPT INTERCEDED THUS ERASING YOUR NEEDED RESUME POINTER.
;	FOR THIS REASON, BE CAREFUL WITH RESUMES.  YOU SHOULD ALWAYS THINK
;	ABOUT WHAT WOULD HAPPEN IF AN INTERRUPT TOOK PLACE BEFORE YOUR
;	RESUME COMMAND AND REMEMBER THAT INTERRUPTS ARE DISABLED AT THE
;	START OF AN INTERRUPTING ROUTINE.    ALSO REMEMBER THAT YOUR
;	REGISTER IS NOT SAVED DURING AN INTERRUPT.  YOU SHOULD NOT USE
;	IT IF YOU ARE GOING TO RESUME BECAUSE YOU'LL CHANGE ITS CONTENTS.
;
;	AFTER THE RESUME IS ISSUED, CLOCKPHASE MORE COMMANDS ARE EXECUTED
;	AT THE RESUME POINT.  THIS IS DONE TO KEEP FROM LOCKING OUT
;	YOUR OTHER CODE IN CASES SUCH AS A WORLD COLUMN COMMAND.  THUS
;	IF YOUR CLOCKPHASE IS 3 THEN 3 COMMANDS WILL BE EXECUTED AFTER
;	YOUR RESUME.
;
;	HERE IS A RULE YOU MUST FOLLOW!!!:  INTERRUPTS MUST REMAIN DISABLED
;	FROM THE START OF AN INTERRUPTING ROUTINE UNTIL ANY POINT WHERE
;	A RESUME MIGHT TAKE PLACE.  OTHERWISE, JUST BEFORE YOU RESUME IS
;	EXECUTED AN INTERRUPTING ROUTINE MIGHT DESTROY THE RESUME POINT
;	AND WHEN YOU FINALLY DID HIT THAT RESUME YOU'D BE IN AN ENDLESS
;	LOOP.
;18 =	<DING> DING.  USED TO MAKE A BELL FOR DEBUGGING.
;19 =	<FINISH> WAIT FOR ANIMATION TO FINISH AND FREEZE.  USE THIS FOR 
;	AUTOFREEZE ANIMATIONS SUCH AS ATTACKS THAT YOU WANT TO WAIT TO 
;	COMPLETE VISUALLY BEFORE CONTINUING.  IT IS RECOMMENDED THAT YOU 
;	USE THE DELAY COMMAND AFTER THIS FOR A DURATION OF 2 TO INSURE 
;	THAT THE LAST FRAME OF THE ANIMATION WAS UP LONG ENOUGH TO SEE. OR
;	ADD AN EXTRA FRAME TO THE END THAT SHOWS THE SAME FRAME.
;1A =   <SETCOUNTER> SET COUNTER.  THE COUNTER WILL TICK DOWN AT THE RATE OF 
;	1/15 SECOND AND STOP AT 0.  IF YOU CHANGE CLOCKPHASE TO 1/30 SECOND,
;	YOUR COUNTER (AND ALTERNATE) WILL RUN AT THE NEW SPEED. 
;	1 BYTE FOLLOWS THIS COMMAND:
;		1 BYTE COUNTER VALUE.  USE 0 <REGISTER> IF YOU WANT TO GET
;		  THE LOW BYTE OF THE REGISTER. IF YOU ACTUALLY WANTED TO CLEAR
;		  THE COUNTER, PUT 1 HERE AND IT WILL BE CLEAR NEXT CYCLE.
;1B =	<COUNT> MOVE EXECUTE POINTER IF COUNTER IS BELOW OR EQUAL TO A 
;	SPECIFIED VALUE.  SEE <ABOVECOUNT> 3 BYTES FOLLOW THIS COMMAND:
;		1 WORD NEW POINTER
;		1 BYTE COUNTER VALUE TO BE BELOW.
;
;1C =	<FRICTION> SPECIFY FRICTION.  FRICTION VALUES SHOULD BE + AND SMALL
;	(0-32) BUT NEGATIVE FRICTIONS MAY BE USED FOR WEIRD EFFECTS (NOT -1).
;	2 BYTES FOLLOW THIS COMMAND:
;		1 BYTE NEW X FRICTION (-1 FOR NO CHANGE)
;		1 BYTE NEW Y FRICTION (-1 FOR NO CHANGE)
;1D =	<GOTO> ABSOLUTE PUT OF ENTITY TO A SCREEN POSITION.  SEE WORLDGOTO.
;		2 BYTES FOLLOW THIS COMMAND:
;		1 BYTE SCREEN X LEFT SIDE LOCATION OR <REGISTER> OR -1 
;		FOR NO CHANGE. (YOU CAN'T USE 0 FOR THE X, LOAD REGISTER 
;		WITH 0)
;		1 BYTE SCREEN Y LOCATION FOR THIS ENTITIES FEET.
;		  <REGISTER> FOR REGISTER CONTENT OR -1 FOR NO CHANGE.
;		  (YOU CAN'T USE 0 FOR THE Y, LOAD REGISTER WITH 0).
;		  NOTE: IF YOU TRY TO LOAD REGISTER WITH -1 YOU WILL GET
;		  THE SAME RESULTS AS -1 AS WITH ALL COMMANDS.
;1E =	<DIE> GO AWAY.  THIS COMMAND WILL CAUSE YOUR ENTITY TO GO INACTIVE AND
;	FREE UP THE ENTITY SLOT.  DON'T USE THIS COMMAND ON THE HERO
;	OR YOU WILL LOOSE CONTROL OF THE GAME. 1 BYTE FOLLOWS THIS COMMAND:
;		1 BYTE FLAG:
;		     0 = DON'T MARK AS KILLED
;		     1 = MARK ENTITY AS HAVING BEEN KILLED
;		     2 = MARK ENTITY AS HAVING BEEN KILLED BUT KEEP
;		         EXECUTING CODE ANYWAY.  
;1F =	<LAUNCH> RELATIVE LAUNCH OF AN ENTITY.  USE THIS COMMAND TO 
;	THROW BULLETS, BOMBS, OR FOR SPECIAL STRUCTURES COMPRISED OF 
;	MULTIPLE ENTITIES SUCH AS WHIPS.  4 BYTES FOLLOW THIS COMMAND:
;		1 BYTE ENTITY NUMBER TO LAUNCH.  USE 0 <REGISTER> TO USE
;		  THE VALUE IN THE ENTITIES REGISTER.  THIS
;		  MEANS YOU CAN'T LAUNCH ENTITY 0 WITH THIS COMMAND!
;		1 BYTE LAUNCH X OFFSET RELATIVE TO THIS ENTITIES LEFT CORNER.
;		1 BYTE LAUNCH Y OFFSET RELATIVE TO THIS ENTITIES TOP.
;		1 BYTE VALUE TO PLACE INTO PARAM2 OF THAT ENTITY.
;20 =	<STANDING> MOVE EXECUTE POINTER IF IN CONTACT WITH SOLID.
;	2 BYTES FOLLOW THIS COMMAND:
;		1 WORD NEW POINTER
;
;21 =	<DAMAGE> APPLY DAMAGE TO HEALTH.  THIS COMMAND WILL TAKE THE DAMAGE 
;	REQUESTED WHEN THIS ENTITY WAS LAST ATTACKED AND APPLY IT TO THE 
;	ENTITIES CURRENT HEALTH LEVEL. THE DAMAGE WILL THEN BE CLEARED. IF THE
;	ENTITIES HEALTH GOES TO ZERO IT WILL REMAIN AT ZERO.
;22 =	<ASSESS> MOVE EXECUTE POINTER IF HEALTH IS LESS THAN OR EQUAL TO A
;	VALUE.  THIS COMMAND ALLOWS YOU TO DECIDE WHEN TO EITHER "THROW" 
;	YOUR ENTITY BACK TO PREVENT CONTINUOUS DAMAGE OR WHEN TO MAKE IT
;	DIE. MANY OF THE COMPARE COMMANDS USE LESS THAN ONLY BUT THIS ONE
;	ALSO INCLUDES EQUAL TO SINCE THE MOST COMMON VALUE TO LOOK FOR
;	IS ZERO.  IF YOU WANT MORE CONTROL OVER APPRAISING HEALTH, USE
;	THE FETCHREG COMMAND TO GET THE VALUE. 3 BYTES FOLLOWS THIS COMMAND:
;		1 WORD NEW POINTER
;		1 BYTE HEALTH VALUE TO TEST FOR
;23 =	<ATTACKER> MOVE EXECUTE POINTER IF LAST ATTACKER MATCHES.  EVEN IF
;	HURTING IS DISABLED YOU CAN USE THIS COMMAND.  THE LAST ATTACKER
;	IS SET TO 255 AT ENEMY LAUNCH SO IF YOU ARE CHECKING FOR AN
;	ENTITY OTHER THAN 255 YOU CAN CONTINUALLY LOOP USING THIS COMMAND
;	UNTIL YOU FIND THE ONE YOU WANT. 3 BYTES FOLLOW THIS COMMAND:
;		1 WORD NEW POINTER
;		1 BYTE ENTITY NUMBER FROM ENTITYTAB OF LAST ATTACKER TO 
;		  LOOK FOR.
;24 =	<ATTACK> MOVE EXECUTE POINTER IF GIVEN ATTACK WAS SPECIFIED.  
;	THIS COMMAND ALLOWS YOU TO SEE WHAT ATTACK THE LAST ATTACKER REQUESTED 
;	AGAINST YOUR ENTITY.  THE ATTACK HE REQUESTED WAS SPECIFIED IN HIS 
;	DAMAGE FLAGS AND ALLOWS VALUES 0-F.  3 BYTES FOLLOW THIS COMMAND:
;		1 WORD NEW POINTER
;		1 BYTE ATTACK NUMBER TO MATCH
;25 =	<SPEED> MOVE EXECUTE POINTER IF MOMENTUM IS BELOW OR = TO A GIVEN VALUE.  
;	THIS COMMAND ALLOWS YOU TO MAKE AN ENTITY FLOW INTO A "STANDING"
;	ANIMATION SEQUENCE WHEN HIS MOMENTUM DROPS TOO LOW.  OR YOU CAN
;	DECIDE TO ENTER A RUNNING MODE IF IT GETS TOO FAST.
;	THERE ARE 2 TYPES OF MOMENTUM, X AND Y AXIS.  THIS COMMAND CAN
;	TEST EITHER OR BOTH BUT IT WILL ONLY TEST THE ABSOLUTE VALUE
;	OF THE MOMENTUM, IT CONVERTS NEGATIVE MOMENTUM TO + BEFORE
;	CHECKING.  IF BOTH MOMENTUMS ARE TESTED, BOTH MUST PASS THE
;	TEST.  REMEMBER THAT MOMENTUM IS STORED IN HIGHER RESOLUTION
;	THAN WILL ACTUALLY PRODUCE MOVEMENT. BEFORE MOVING THE ENTITY
;	IT IS DIVIDED BY 8.  4 BYTES FOLLOW THIS COMMAND:
;		1 WORD NEW POINTER
;		1 BYTE X MOMENTUM OR -1 FOR DON'T CARE
;		1 BYTE Y MOMENTUM OR -1 FOR DON'T CARE
;26 =	<REARM> RE-ARM ATTACK.  ATTACKS ARE ARMED WHEN A NEW SPRITE ANIMATION
;	IS LOADED.  THE DAMAGE FLAGS MUST ALSO ENABLE ATTACK.  WHEN THE
;	ATTACK IS TRIGGERED, THAT ENTITY WILL NOT ATTACK AGAIN UNTIL
;	A NEW ANIMATION IS LAUNCHED OR UNTIL THIS COMMAND IS ENCOUNTERED.
;	USE THIS COMMAND IN A LOOP FOR A CONTINUOUS ATTACKER.   REARMING
;	DOES NOT RESET THE ATTACKED BIT USED BY THE <ATTACKED> COMMAND.
;27 =	<ATTACKED> MOVE EXECUTE POINTER IF YOU HAVE ATTACKED SOMEONE.  WHEN AN ENTITY
;	ATTACKS SOME OTHER ENTITY, A BIT IS SET.  YOU CAN TEST THIS AND
;	BRANCH.  THE BIT IS RESET BY THE TEST.  2 BYTES FOLLOWS THIS:
;		1 WORD NEW POINTER
;28 =	<FRAME> MOVE EXECUTE POINTER IF ANIMATION FRAME IS EQUAL TO OR GREATER 
;	THAN. THIS COMMAND IS USED TO MAKE SPECIAL EFFECTS TIMED TO YOUR 
;	ANIMATION WITHOUT RESORTING TO USE OF THE COUNTER.  FOR INSTANCE, AN 
;	ENTITY THAT THROWS A ROCK ON FRAME #3.  YOUR ANIMATION SHOULD BE SELF
;	FREEZING FOR BEST RESULTS.  IF YOU WANT IT TO GO OVER AND OVER,
;	BEST TO WAIT FOR THE FREEZE AND THEN REPEAT THE SAME LOGIC BY
;	USING ACTIVATE WITH THE SAME ANIMATION/MOVEMENT LIST.  3 BYTES
;	FOLLOW THIS COMMAND:
;		1 WORD NEW POINTER
;		1 BYTE FRAME #
;29 =	<DISPLAY> GO INFRONT/BEHIND BACKGROUND.  1 BYTE FOLLOWS THIS COMMAND:
;		1 BYTE.  0=<TOFRONT> .  H'20=<BEHIND> 
;2A =	<WORLDCMD> MOVE EXECUTE POINTER IF PARAM1 PASSED BY A WORLD COMMAND
;	MATCHES A GIVEN VALUE.  WHEN YOUR ENTITY STEPS ONTO A WORLD COMMAND
;	AND IS BETWEEN THE SPECIFIED ROWS IN THE COMMAND, THE LAST 2 BYTES
;	OF THE COMMAND ARE PLACED IN PARAM1 AND PARAM2 FOR YOU TO TEST.
;	SINCE PARAM1 IS RECOMMENDED TO BE THE COMMAND BYTE, THE TEST FOR
;	IT HAS BEEN NAMED WORLDCMD TO CLARIFY YOUR CODE.  THIS COMMAND
;	WILL MOVE THE EXECUTE POINTER IF PARAM BYTE #1 MATCHES THE ONE
;	YOU SPECIFY.  SEE THE KUNGFU.ASM MODULE FOR THE EQUATES TO USE
;	FOR A GIVEN COMMAND AND TRY TO STICK TO THEM FOR READIBILITY.
;	3 BYTES FOLLOW THIS COMMAND:
;		1 WORD NEW POINTER
;		1 BYTE VALUE TO MATCH.
;			EXAMPLE USAGE:  
;			.DB	WORLDCMD	;SEE WHAT THE COMMAND IS
;			.DRW	WALKUP		;YOUR CODE THAT WALKS UP
;			.DB	DOOR		;IF THE COMMAND IS A DOOR
;2B =	<IFPARAM> MOVE EXECUTE POINTER IF PARAM2 IS A GIVEN VALUE.  SEE ABOVE
;	DESCRIPTION, THIS COMMAND TESTS THE SECOND PARAMETER BYTE.
;	3 BYTES FOLLOW THIS COMMAND:
;		1 WORD NEW POINTER
;		1 BYTE VALUE TO MATCH
;
;2C =   <INSTRUCTIONS> SET INSTRUCTIONS LEFT TO EXECUTE.  THE STATE MACHINE
;	WILL EXECUTE UP TO 2 INSTRUCTIONS PER CYCLE FOR EACH ENTITY.  IF
;	A MOMENTUM COMMAND IS ENCOUNTERED, THE CYCLE WILL END EVEN IF THAT
;	WAS THE FIRST INSTRUCTION (THIS IS DONE TO PACE OUT YOUR MOMENTUM
;	TO A GUARANTEED RATE).  THE INSTRUCTIONS COMMAND ALLOWS YOU TO
;	FORCE THE EXECUTION OF A NUMBER OF INSTRUCTIONS.  YOU CAN FORCE
;	EXECUTION OF THIS MANY INSTRUCTIONS EVEN IF MOMENTUM COMMANDS
;	ARE ENCOUNTERED OR YOU CAN FORCE EXECUTION OF THIS MANY INSTRUCTIONS
;	UNTIL A MOMENTUM COMMAND IS ENCOUNTERED.  THIS IS USEFUL FOR
;	ROUTINES THAT DON'T KNOW IF THEY WERE CALLED AS A SECOND INSTRUCTION
;	FROM ANOTHER PLACE AND THUS HAVE ONE MORE LEFT TO RUN OR IF THEY
;	WERE INTERRUPTED INTO AND HAVE 2. ALSO, YOU CAN BETTER CONTROL
;	SYSTEM STATUS FOLLOWING AN ENABLE BUTTON COMMAND IF YOU CAN
;	GUARANTEE TO FINISH INSTRUCTIONS BEFORE AN INTERRUPT FROM THE
;	BUTTON.  BE CAREFUL WITH THIS COMMAND BECAUSE PROCESSOR POWER IS
;	LIMITED AND ALL OTHER ENTITIES ARE LOCKED OUT UNTIL YOUR INSTRUCTIONS
;	ARE EXECUTED.  ALL 16 ENTITIES HAVE TO EXECUTE WITHIN 1/15 SECOND
;	OR THE MACHINE WILL MISS A CYCLE AND IT WILL LOOK JERKY OR SLOW DOWN.
;
;	PLEASE NOTE THAT THE FOLLOWING COMMANDS WILL CAUSE TERMINATION EVEN
;	IF YOU FORCE EXECUTION WITH A VALUE ABOVE 80H: DIE, WORLD, DELAY,
;	FREEZE, TESTFLAG, RESUME.
;
;	1 BYTE FOLLOWS THIS COMMAND:
;		0-7F TO FORCE EXECUTION OF THAT MANY COMMANDS FOLLOWING
;			THE COMMAND ITSELF. IF MOMENTUM IS ENCOUNTERED, IT
;			WILL ABORT THE REMAINING INSTRUCTIONS.   0 WILL
;			FORCE THIS TO BE THE LAST INSTRUCTION.
;		80-FF TO FORCE EXECUTION OF THAT MANY INSTRUCTIONS (LOW 7 
;		        BITS ONLY) NO MATTER WHAT.  80 IS 0, 81 IS 1, ETC.
;2D =	<SETMOM>  SET MOMENTUM (REPLACE OLD VALUE).  THIS
;	COMMAND IS USED TO SET THE X OR Y MOMENTUM VALUES TO A SPECIFIED
;	VALUE. USE THIS FOR ENTITIES THAT MOVE AT EXACT RATES WITHOUT
;	THE "OVERSHOOTING" OF ENTITIES THAT ADD MOMENTUM.  YOUR MOMENTUM
;	VALUES WILL BE SIGN CORRECTED FOR THE TRACKING YOU HAVE SELECTED
;	WITH XTRACK AND YTRACK IN CONJUNCTION WITH THE TARGET COMMAND.
;	2 BYTES FOLLOW THIS COMMAND:
;		1 BYTE NEW X MOMENTUM VALUE (<NOCHANGE> OR -1 FOR NO CHANGE)
;		1 BYTE NEW Y MOMENTUM VALUE (<NOCHANGE> OR -1 FOR NO CHANGE)
;
;	SAMPLE USAGE:   .DB	SETMOM,0,0	;WILL STOP ENTITY ON X AND Y
;
;	TRICKY NOTE:  SUPPOSE YOU WANT TO STOP YOUR MOMENTUM BUT KEEP FACING
;	THE DIRECTION YOU ARE.  THE DIRECTION YOU ARE FACING DOES NOT
;	GET ADJUSTED UNTIL ALL INSTRUCTIONS FOR THE ENTITY IN THE CURRENT
;	CYCLE HAVE BEEN COMPLETED.  SO YOU CAN USE SETMOM IN CONJUNCTION
;	WITH MOVEIN TO KEEP FACING THE CURRENT DIRECTION (ASSUMING YOU
;	ARE FACING IN THE DIRECTION OF TRAVEL):
;			.DB	INSTRUCTIONS,H'82
;			.DB	SETMOM,0,-1
;			.DB	MOVEIN,7,0	;KEEP FACING CURRENT DIR.
;
;2E =	<TESTFLAG> TEST FOR WORLD COLUMN FLAGS.  THIS COMMAND FORCE THE
;	TESTING OF THE ENTITIES CURRENT SCREEN COLUMN POSITION TO SEE IF
;	THERE IS A WORLD COMMAND THERE.  USE THIS FOR SITUATIONS SUCH
;	AS CLIMBING UP A LADDER IN WHICH YOU WISH TO SEE IF THE ENTITY
;	IS STILL ON A LADDER REGION.  ONCE YOU RUN THIS COMMAND, YOUR
;	ENTITY EXECUTION WILL BE ENDED (EVEN IF YOU HAVE FORCED A NUMBER
;	OF COMMANDS TO EXECUTE).  THEN THE NEXT INSTRUCTION WILL BE RUN
;	IF THERE WAS NO COMMAND THERE OR IF THERE WAS THEN YOUR ECMD
;	ROUTINE WILL BE RUN INSTEAD.  
;2F =	<DISABLE> THIS COMMAND IS USED TO DISABLE INTERRUPTION OF YOUR
;	CODE BY EXTERNAL SOURCES.  YOU CAN DISABLE ANY OF THE INTERRUPTING
;	SOURCES INCLUDING THE JOYSTICK BUTTONS.  IF YOU SPECIFY TO
;	DISABLE A GIVEN FUNCTION AND ANOTHER IS ALREADY DISABLED, BOTH
;	WILL NOW BE DISABLED.  A FUNCTION REMAINS DISABLED UNTIL YOU
;	ENABLE IT.  ALSO, ANY INTERRUPTING ROUTINE DISABLES ALL INTERRUPTS
;	AUTOMATICALLY.  WHILE DISABLED, EVENTS THAT WOULD INTERRUPT YOU
;	ARE TOSSED OUT, THEY ARE NOT QUED.  BE CAREFUL DISABLING
;	HURT MODE SINCE YOUR ENTITY BECOMES INVULNERABLE.  1 BYTE
;	FOLLOWS THIS COMMAND:
;		1 BYTE FLAG OF WHAT TO DISABLE:
			.EQU	HURTING,H'01	;(EHURT)
			.EQU	FALLING,H'02	;(EFALL)
			.EQU	TESTING,H'04	;FOR WORLD COMMAND (ECMD)
			.EQU	JUMPING,H'08	;(EJUMP)
			.EQU	ATTACKING,H'10	;(EATTACK)
			.EQU	SELECTING,H'20	;SELECT KEY
			.EQU	DUCKING,H'40	;(EDUCK)
			.EQU	ALL,H'FF	;ALL OF THEM.

;	EXAMPLE: .DB DISABLE,FALLING | JUMPING	;DISABLES FALLING AND JUMPING
;
;30 =	<ENABLE>  THIS COMMAND IS THE OPPOSITE OF DISABLE.  REMEMBER THAT
;	ALL INTERRUPTS ARE DISABLED AT THE START OF A NEW INTERRUPT AND
;	YOU MUST USE THIS COMMAND TO ENABLE THEM OR YOU MUST USE A RESUME.
;	ALSO, WHEN AN ENTITY IS FIRST LAUNCHED, YOUR WAKEUP CODE NEEDS
;	TO ENABLE INTERRUPTS AS DESIRED BECAUSE THEY START OUT DISABLED.
;31 =	<SOUND> THIS COMMAND ALLOWS YOU TO LOAD OR CONTROL EACH OF THE
;	FOUR SOUND CHANNELS AVAILABLE TO THE STATE MACHINE.  YOU SPECIFY
;	THE NEW DESIRED STATE FOR EACH OF THE CHANNELS IN A SINGLE COMMAND.
;	YOU CAN EITHER START MUSIC OR A SOUND EFFECT, SILENCE ONE OR MORE
;	CHANNELS, OR LEAVE ANY OF THEM ALONE.  HOW YOU WANT TO USE THESE 
;	CHANNELS DEPENDS ON YOUR GAME DESIGN.  SUGGESTED USAGES:  
;	CHANNELS 0 AND 1 ARE FOR MUSIC USING VOICES 0 AND 1, CHANNEL 2 IS 
;	FOR BASE AND RYTHM USING VOICE2, CHANNEL 3 IS FOR SOUND EFFECTS 
;	OR PERCUSSION USING VOICE 3. 8 BYTES FOLLOW THIS COMMAND:
;		1 WORD NEW MUSIC FOR CHANNEL 0 (-1=DON'T CHANGE, 0=SILENCE)
;		1 WORD NEW MUSIC FOR CHANNEL 1 (OR -1 OR 0)
;		1 WORD NEW MUSIC FOR CHANNEL 2 (OR -1 OR 0)
;		1 WORD NEW MUSIC FOR CHANNEL 3 (OR -1 OR 0)
;	NOTE THAT FOR SOUND EFFECTS LIKE EXPLOSIONS, ANOTHER SLOT TO
;	INTERRUPT THIS ONE IS NEEDED.  USE THE <NOISE> COMMAND.  IT
;	PROVIDES ANOTHER SLOT THAT WILL INTERRUPT ANY OF THESE YET
;	PRESERVE THE MUSIC FOR THE WORLD IN CASE IT USES ALL 4 OF THESE
;	SLOTS.  IT IS RECOMMENDED TO USE THE <NOISE> COMMAND FOR ENEMY
;	NOISES AND THE <SOUND> COMMAND FOR MUSIC.
;32 =	<BOUNCE> THIS COMMAND WILL SPECIFY THE BOUNCE FACTOR FOR THE
;	ENTITY.  YOU CAN SPECIFY A POSITIVE BOUNCE FROM 0 TO 255.
;	THE VALUE YOU SPECIFY IS INCREMENTED PRIOR TO USAGE. 
;	THE MOMENTUM AFTER BOUNCING WILL BE THE RATIO OF THE ORIGINAL
;	VALUE X AS FOLLOWS:  NEW MOMENTUM = (OLD MOMENTUM)*(X+1)/256.
;	THIS MEANS THAT A VALUE OF 255 IS INCREMENTED TO 256 AND PRODUCES
;	A PERMANENT BOUNCE.  A VALUE OF 0 IS AUTOMATICALLY IGNORED AND
;	CONSIDERED THE BOUNCE DISABLE.
;
;	ALL BOUNCE FACTORING TAKES PLACE ONLY WHEN A GIVEN AXIS CONTACTS
;	SOLID AND HAS MOVED PREVIOUSLY.  SO FOR INSTANCE, GRAVITY DOES
;	NOT PRODUCE BOUNCE ON YOUR ENTITY UNLESS IT HITS THE SURFACE.
;	IT WON'T OSCILATE JUST BECAUSE ITS IN CONTACT.  HERE ARE SOME
;	SAMPLE BOUNCE FACTORS AND WHAT THEY DO:
;		255 REVERSES THE ENTITY WITH THE SAME VELOCITY
;		127 REVERSES THE ENTITY WITH HALF THE VELOCITY.
;		 32 REVERSES THE ENTITY WITH 1/8 VELOCITY.
;		  0 CANCELS BOUNCE ENTIRELY
;	1 BYTE FOLLOWS THIS COMMAND:
;		1 BYTE BOUNCE FACTOR.
;
;33 =	<SETJOYX> SET JOYSTICK X MOMENTUM.  THE CURRENTLY STORED X AXIS
;	JOYSTICK MOMENTUM WILL REPLACE THE ENTITIES CURRENT X AXIS MOMENTUM
;	AND THE JOYSTICK MOMENTUM WILL BE ZEROED AFTER USAGE.
;34 =	<SETJOYY> SET JOYSTICK Y MOMENTUM.  SAME AS SETJOYX BUT IT
;	WORKS WITH THE Y MOMENTUM.
;35 =	<ACTIVE>  MOVE EXECUTE POINTER IF ENTITY IS ACTIVE.  IF THE
;	SPECIFIED ENTITY IS ACTIVE, THE EXECUTE POINTER IS MOVED.  YOU
;	CAN SPECIFY THE ENTITY BY WORLD COLUMN FLAG THAT LAUNCHED IT OR
;	BY THE NUMBER OF THE ENTRY IN THE ENTITYTAB.  IF THE ENTITY WAS
;	LAUNCHED BY ANOTHER ENTITY, YOU MUST USE THE ENTRY NUMBER FROM
;	ENTITYTAB SINCE NO WORLD COLUMN LAUNCHED IT.  YOU CAN CHECK FOR
;	ENTITIES OF YOUR OWN ID SAFELY, IT WON'T REPORT YOURSELF AS
;	BEING ACTIVE.  5 BYTES FOLLOW THIS COMMAND:
;		1 WORD NEW POINTER
;		1 BYTE IDENTIFICATION TYPE:
			.EQU	COLUMN,0	;TO SPECIFY BY WORLD COLUMN
			.EQU	ID,1		;TO SPECIFY BY ENTITY #
;		1 WORD NUMBER TO MATCH.  IF FROM ENTITYTAB, ONLY LOW BYTE
;		  IS USED.  IF WORLD COLUMN, FULL WORD.  YOU CAN ALSO SPECIFY
;		  <REGISTER> FOR THE VALUE IN THE REGISTER (USES FULL WORD
;		  IF ID BY COLUMN, BYTE IF BY ID).  SINCE 0 IS <REGISTER>
;		  THIS MEANS YOU CAN'T MATCH 0 UNLESS YOU LOAD THE 
;		  REGISTER WITH 0.
;
;	SAMPLE USAGE:	.DB	ACTIVE
;			.DRW	HAVEBUGS	;SKIP TO HAVEBUGS
;			.DB	ID		;IF ENTITY
;			.DRW	23		;#23 IS ACTIVE
;
;36 =	<HURT>  HURT THE SPECIFIED ENTITY WITH THE SPECIFIED ATTACK
;	AND DAMAGE LEVEL.  THIS COMMAND ALLOWS YOU TO HURT AN ENTITY
;	OR ENTITIES WITHOUT ACTUALLY LAUNCHING AN ATTACK AGAINST THEM.
;	TYPICALLY, YOU WOULD USE IT TO REPORT TO AN ENTITY THAT YOU WANT
;	IT TO GO AWAY.   FOR INSTANCE, YOU MIGHT HAVE A WHIP WEAPON THAT
;	IS ATTACHED TO YOUR ENTITY AND AN UNUSUAL OCCURANCE MAKES IT
;	NECESSARY TO REMOVE IT PREMATURELY.  YOU CAN HURT IT DIRECTLY
;	AND REPORT AN ATTACK NUMBER TO IT THAT IT UNDERSTANDS AS A MESSAGE
;	TO GO AWAY.  IF YOU SPECIFY TO HURT BY ENTITY NUMBER FROM ENTITYTAB,
;	ALL ENTITIES WITH THAT NUMBER ARE HURT.   THIS ROUTINE DOES
;	NOT SET THE BIT SIGNALING THAT YOU ATTACKED SOMEONE NOR DOES IT
;	SET THE LAST VICTIM VARIABLE.  4 BYTES FOLLOW THIS COMMAND:
;		1 BYTE DAMAGE FLAG #3 TO USE, SAME AS IN ANIMATION 
;			TABLE DEFINITION
;		1 BYTE IDENTIFICATION TYPE OF THE ENTITY (<COLUMN> OR <ID>).
;		  	SEE COMMAND <ACTIVE> FOR MEANING OF EACH. YOU
;		        CAN ALSO SPECIFY <ALL> TO HURT ALL ENTITIES ON 
;			SCREEN EXCEPT FOR JOYSTICK ENTITIES.
;		1 WORD NUMBER TO MATCH.  IF FROM ENTITYTAB, ONLY LOW BYTE
;		  IS USED.  IF WORLD COLUMN, FULL WORD.  YOU CAN ALSO SPECIFY
;		  <REGISTER> FOR THE VALUE IN THE REGISTER. THIS MEANS YOU 
;		  CAN'T MATCH 0 UNLESS YOU LOAD THE REGISTER WITH 0.
;
;37 =	<ADDSCORE> ADD TO THE SCORE.  SCORES ARE ASSIGNED TO JOYSTICKS.
;	THERE ARE 2 SCORES KEPT BY THE STATE MACHINE AND EACH IS 2 BYTES.
;	THIS ALLOWS VALUES UP TO 65535.  TYPICALLY, YOU WOULD MULTIPLY
;	THE SCORE BY 100 WHEN DISPLAYED BY SIMPLY PAINTING 2 ZEROS TO THE
;	RIGHT OF IT.  YOU CAN ADD ANY 1 WORD VALUE TO THE SCORE.  IF THE
;	VALUE IS BELOW H'8000 IT WILL BE TREATED AS A POSITIVE VALUE AND
;	THE SOFTWARE WILL STOP AT 65535 IF OVERFLOW OCCURS.  IF THE VALUE
;	IS ABOVE H'8000, IT WILL BE TREATED AS A NEGATIVE VALUE AND
;	THE SOFTWARE WILL STOP AT 0 UNDER THE ASSUMPTION YOU ARE SUBTRACTING
;	YOUR VALUE FROM THE SCORE AS A PENALTY OF SOME KIND.  SINCE THE SCORE
;	DISPLAY IS ALSO UNDER YOUR CONTROL, YOU COULD ADD SLOWLY AND MAKE
;	A "DINGING" SOUND WITH EACH ADDITION TO SIMULATE A PINBALL MACHINE
;	BONUS EFFECT.   3 BYTES FOLLOW THIS COMMAND:
;		1 BYTE SCORE TO ADD TO:
			.EQU	JOY1,0		;JOYSTICK 0
			.EQU	JOY2,1		;JOYSTICK 1
			.EQU	OURJOY,2	;JOYSTICK OF THIS ENTITY
						;(IF NONE, WILL IGNORE CMD)
			.EQU	KILLERSJOY,3	;JOYSTICK OF LAST ATTACKER
						;(IF NONE, WILL IGNORE CMD)
;		1 WORD VALUE TO ADD TO THE SCORE OR <REGISTER> TO ADD
;		THE FULL WORD REGISTER CONTENTS 

;	SAMPLE USAGES:	.DB	ADDSCORE,KILLERSJOY	;ADDS 2 TO SCORE OF
;			.DRW	2			;LAST ATTACKER.
;
;			.DB	ADDSCORE,OURJOY		;PENALIZES US FOR 
;			.DRW	-5			;5 POINTS.
;
;38 =	<SETSCORE> SET THE SCORE.  FUNCTIONS THE SAME AS ADDSCORE BUT
;	IT REPLACES THE CURRENT VALUE WITH THE VALUE YOU SPECIFY.  USE
;	THIS IN YOUR BOOT WORLD TO INITIALIZE THE SCORE. YOU CAN'T
;	SET TO THE REGISTER, USE PUTSCORE FOR THIS.  3 BYTES FOLLOW
;	THIS COMMAND:
;		1 BYTE SCORE TO SET
;		1 WORD NEW VALUE			
;
;39 =	<SCORE> MOVE EXECUTE POINTER IF SCORE IS GREATER THAN OR EQUAL TO.
;	THIS CODE ALLOWS YOU TO MAKE DECISIONS BASED ON THE SCORE.  
;	5 BYTES FOLLOW THIS COMMAND:
;		1 BYTE SCORE TO TEST (SEE COMMAND 37)
;		1 WORD SCORE TO BE ABOVE OR EQUAL TO
;		1 WORD NEW POINTER
;
;3A =	<ADDHEROS> ADD TO THE HERO COUNT.  HERO COUNTS ARE ASSIGNED TO 
;	JOYSTICKS. THERE ARE 2 HERO COUNT VARIABLES AND EACH IS 1 BYTE.
;	THIS ALLOWS VALUES UP TO 255 HEROS.  YOU CAN ADD A 1 BYTE VALUE
;	TO THE HEROS COUNT.  IF THE VALUE IS BELOW H'80 IT WILL BE TREATED 
;	AS A POSITIVE VALUE AND	THE SOFTWARE WILL STOP AT 255 IF OVERFLOW 
;	OCCURS.  IF THE VALUE IS ABOVE H'80, IT WILL BE TREATED AS A NEGATIVE 
;	VALUE AND THE SOFTWARE WILL STOP AT 0 UNDER THE ASSUMPTION YOU ARE 
;	SUBTRACTING YOUR VALUE FROM THE HERO COUNT.  
;	2 BYTES FOLLOW THIS COMMAND:
;		1 BYTE JOYSTICK'S HERO COUNT TO ADD TO. SEE CMD 37.
;		1 BYTE VALUE TO ADD TO THE HERO COUNT OR <REGISTER> TO
;		  USE THE REGISTER.  YOU CANNOT SPECIFY ABSOLUTE 0 HERE.
;
;	SAMPLE USAGE:	.DB	ADDHEROS,OURJOY,-1	;DECREMENT HERO COUNT
;
;3B =	<SETHEROS> SET THE HEROS COUNT.  FUNCTIONS THE SAME AS ADDHEROS BUT
;	IT REPLACES THE CURRENT VALUE WITH THE VALUE YOU SPECIFY.  USE
;	THIS IN YOUR BOOT WORLD TO INITIALIZE THE HERO COUNT. 2 BYTES FOLLOW
;	THIS COMMAND:
;		1 BYTE JOYSTICK'S HERO COUNT TO SET (SEE CMD 37)
;		1 BYTE NEW VALUE OR <REGISTER> TO
;		  USE THE REGISTER.  YOU CANNOT SPECIFY ABSOLUTE 0 HERE.
;
;3C =	<HEROS> MOVE EXECUTE POINTER IF HEROS COUNT IS GREATER THAN OR EQUAL
;	TO.  THIS CODE ALLOWS YOU TO MAKE DECISIONS BASED ON THE NUMBER
;	OF HEROS LEFT.  USE <GETHEROS> TO GET THE COUNT INTO THE REGISTER.
;	4 BYTES FOLLOW THIS COMMAND:
;		1 BYTE JOYSTICK HERO COUNT TO TEST (SEE COMMAND 37)
;		1 BYTE HERO COUNT TO BE ABOVE OR EQUAL TO
;		1 WORD NEW POINTER
;
;	SAMPLE USAGE:	.DB	HEROS,OURJOY,1 	;IF THERE ARE 1 OR MORE
;			.DRW	CONTINUE	;HEROS, GO TO CONTINUE:
;			.DB	SKIP		;OTHERWISE
;			.DRW	GAME_OVER	;GO TO GAME OVER LOGIC.
;
;3D =	<RESET> MOVE EXECUTE POINTER IF RESET FLAG IS FALSE.  THIS COMMAND
;	ALLOWS YOU TO INITIALIZE VARIABLES AFTER A SYSTEM RESET.  THE
;	RESET VARIABLE IS SET TRUE BY THE STATE MACHINE FOLLOWING A 
;	RESET OF THE NES.  NEXT WORLD #0 IS ACTIVATED.  YOU WORLD 0
;	CODE IS RESPONSIBLE FOR DETECTING THE START BUTTONS AND THE
;	CONTINUE OR SELECT BUTTONS.  IT SHOULD TEST THIS FLAG TO DECIDE
;	WHEN TO ZERO SCORES OR RESET HERO COUNTS OR PRIZES. AFTER YOU
;	USE THIS INSTRUCTION, THE RESET VARIABLE IS SET TO ZERO.  IF
;	YOU PUT THIS COMMAND IN YOUR BOOT LOGIC, SET THE POINTER TO JUMP
;	OVER THE INITIALIZATION VARIABLES AND YOU WILL EXECUTE THEM ONLY
;	IF ITS A RESET.
;	1 WORD FOLLOWS THIS COMMAND:
;		1 WORD NEW POINTER
;
;3E =	<SETREG>  THIS COMMAND ALLOWS YOU TO LOAD THE ENTITIES SINGLE
;	REGISTER WITH A #. THIS REGISTER IS USED TO TAKE SYSTEM VARIABLES OR
;	RANDOM NUMBERS AND USE THEM IN OTHER COMMANDS.  COMMANDS WILL
;	SPECIFY WHEN THEY ACCEPT <REGISTER> AS A PARAMETER.  THIS
;	COMMAND ALLOWS LOADING A FIXED VALUE INTO THE REGISTER.  2
;	BYTES FOLLOW THIS COMMAND:
;		1 WORD NUMERIC VALUE TO LOAD INTO THE REGISTER
;
;3F =	<FETCHREG> THIS COMMAND ALLOWS YOU TO GET STATE MACHINE VARIABLES
;	INTO THE REGISTER FOR USE WITH COMMANDS THAT ACCEPT THE REGISTER
;	AS INPUT.  IF THE VALUE YOU ARE GETTING IS ONLY A BYTE, THE HIGH
;	BYTE OF THE REGISTER IS ZEROED.  1 BYTE FOLLOWS THIS COMMAND TO 
;	SPECIFY WHAT TO GET INTO THE REGISTER:
;		1 BYTE WHAT TO GET:
;			<PARAM2> FOR THE ENTITIES PARAM2
;			<RANDOM> FOR A RANDOM NUMBER
;			<WORLDCMD> FOR THE LAST WORLD COMMAND WE HIT
;			<ATTACKER> FOR THE LAST ATTACKER.  THIS IS SET
;				TO -1 AT LAUNCH SO THAT YOU CAN HAVE AN
;				ENTITY WITH HURTING DISABLED.  EVEN WITH
;				HURTING DISABLED THIS WILL RETURN AN
;				ATTACK AGAINST YOU.
;			<ATTACK> FOR THE LAST ATTACK USED AGAINST THIS
;				ENTITY.  INVALID UNTIL YOU HAVE BEEN ATTACKED
;				AND IT IS NOT CLEARED AT LAUNCH.
;		   	<VICTIM> FOR THE LAST PERSON YOU ATTACKED
;			<WORLD> FOR THE CURRENT WORLD #
;			<HEALTH> FOR THIS ENTITIES HEALTH LEVEL
;			<ENTITY> FOR THIS ENTITIE'S ENTITYTAB NUMBER
;			<FACE> FOR THE DIRECTION THIS ENTITY IS CURRENTLY
;				FACING,  1 BYTE BIT ORIENTED:
				 ;BIT 80H = SET IF ENTITY FACING LEFT
				 ;BIT 40H = SET IF ENTITY UPSIDE DOWN
		
;			<XVISUAL> FOR THIS ENTITIES X LOCATION (CENTER)
;			<YVISUAL> FOR THIS ENTITIES Y LOCATION (FEET)
;			<SLOTS> FOR THE NUMBER OF FREE ENTITY SLOTS
;			<XDIR> FOR A FLAG SIGNALING THE DIRECTION OF
;				THE TARGETED ENTITY.  HERE ARE THE VALUES:
;				0=RIGHT OF YOU OR AT SAME X
;				1=LEFT OF YOU 
;				-1= NONE ON SCREEN
;			<YDIR> FOR A FLAG SIGNALING THE Y DIRECTION OF
;				THE TARGETED ENTITY. HERE ARE THE VALUES:
;				0=BELOW YOU OR ON SAME LEVEL
;				1=ABOVE YOU 
;				-1=NONE ON SCREEN
;			<BEHAVIOR> TO GET THE ENTITIES BEHAVIOR BITS
;			<XMOM> FOR THE ENTITIES CURRENT X MOMENTUM
;			<YMOM> FOR THE ENTITIES CURRENT Y MOMENTUM
;			<DEF_SOLID> FOR THE ENTITIES DEFAULT SOLID VALUE
;			       FROM HIS ENTITYTAB ENTRY.
;			<XLINK> FOR THE CURRENT X VALUE FOR A LINK TO
;				AN ENTITY.
;			<YLINK> FOR THE CURRENT Y VALUE FOR A LINK TO
;				AN ENTITY.
;			<MUSTDEFEAT> FOR THE NUMBER OF MUST DEFEAT ENTITIES
;				STILL ACTIVE (EVEN IF ASLEEP-ASLEEP MEANS
;				THEY ARE WAITING TO COME TO A CERTAIN SCREEN
;				COLUMN AS IN LAUNCH BYTE 5 OF COMMAND F0).
;				IF THE ENEMY USING THIS COMMAND IS MARKED 
;				MUSTDEFEAT, ITS NOT COUNTED.
;			<DAMAGE> FOR THE AMOUNT OF DAMAGE THE LAST ATTACK
;				REQUESTED.  USE THIS BEFORE THE DAMAGE
;				COMMAND SINCE IT CLEARS THIS VALUE.  FETCHREG
;				DOES NOT CLEAR IT.
;			<XDIST> FOR THE X DISTANCE TO THE NEAREST TARGETED
;				ENTITY.  ITS THE ABSOLUTE VALUE.  IF NONE,
;				-1 IS RETURNED.
;			<YDIST> FOR THE Y DISTANCE TO THE NEAREST TARGETED
;				ENTITY.  ITS THE ABSOLUTE VALUE.  IF NONE,
;				-1 IS RETURNED.
;			<ENTITYBITS> FOR THE FLAG THAT IS USED IN THE
;				ENTITITES ENTRY IN ENTITYTAB.
;			<TARGET> FOR THE ENTITIES TARGET BITS SET WITH
;				THE LAST TARGET COMMAND (FULL WORD).
;			<CHARSET> FOR THE CURRENT CHARACTER SET.  NOT
;				VALID IF YOU ARE IN A STATREQUEST WORLD.
;			<WIDTH> FOR THE WIDTH OF THIS ENTITY IN PIXELS.
;			
;	SAMPLE USAGE:	.DB	FETCHREG,RANDOM		;GET A RANDOM NUMBER
;			.DB	FETCHREG,PARAM2		;GET PARAMETER 2

;40 =	<ANDREG> THIS COMMAND WILL "AND" YOUR 1 WORD VALUE TO THE ENTITIES
;	REGISTER.  FOR INSTANCE, YOU MIGHT WANT A RANDOM NUMBER FROM 0-F
;	INSTEAD OF 0-FF.  YOU COULD FETCH THE RANDOM AND THEN AND IT TO 0F.
;	2 BYTE2 FOLLOW THIS COMMAND:
;		1 WORD VALUE TO AND TO THIS ENTITIES REGISTER
;
;41 =	<COMPARE> THIS COMMAND ALLOWS YOU TO COMPARE THE ENTITIES REGISTER
;	TO AN ABSOLUTE VALUE AND MOVE THE EXECUTE POINTER IF THE REGISTER 
;	IS ABOVE OR EQUAL TO THIS VALUE.  4 BYTES FOLLOW THIS COMMAND:
;		1 WORD NEW POINTER
;		1 WORD COMPARE VALUE
;42 =	<ADD> THIS COMMAND WILL ADD A 2 BYTE VALUE TO THE ENTITIES REGISTER.
;	ADD A NEGATIVE VALUE TO SUBTRACT.  THIS COMMAND DOES NOT
;	CHECK FOR WRAP ABOVE 1 WORD OR BELOW 0.  2 BYTES FOLLOW THIS COMMAND:
;		1 WORD VALUE TO ADD
;43 =	<SETPAUSE> THIS COMMAND WILL ALLOW YOU TO SET THE CONDITION OF THE
;	PAUSE FUNCTION.  YOU SHOULD SET THIS TO -1 <OFF> TO DISABLE PAUSING 
;	AND 1 <ON> TO ENABLE IT.  IT BEGINS DISABLED AT BOOT.  TYPICALLY,
;	YOUR WORLD 0 CODE SHOULD DISABLE IT AND YOUR WORLD 1 CODE SHOULD
;	ENABLE IT.  YOU CAN LEAVE IT DISABLED AND PUT YOUR CODE INTO
;	AND ENDLESS LOOP MANUALLY TO TAKE CONTROL OF PAUSE BUT THIS IS
;	NOT RECOMMENDED.  1 BYTE FOLLOWS THIS COMMAND:
;		1 BYTE PAUSE STATE DESIRED:
;			<OFF> OR <ON>
;44 =	<TABLE> THIS COMMAND ALLOWS YOU TO SKIP TO A NEW EXECUTION POINT
;	BASED ON THE VALUE IN THE REGISTER.  THE REGISTER IS MULTIPLIED
;	BY 2 AND USED AS AN INDEX INTO YOUR LIST. THE RANGE IS 128 ENTRIES
;	(0-127).  ANOTHER WAY TO LOOK AT IT IS THAT THE NUMBER 
;	IN THE REGISTER WILL BE THE ENTRY YOU 
;	SKIP TO.  0 GETS THE FIRST, 1 THE SECOND, ETC.  A VARIABLE
;	NUMBER OF WORDS FOLLOWS THIS COMMAND.  MAKE SURE YOU HAVE AN 
;	ENTRY FOR EACH POSSIBILITY OR YOU WILL CRASH.  CONSIDER USING
;	THE ANDREG COMMAND FIRST TO LIMIT THE RANGE.  THE HIGH BYTE OF
;	THE REGISTER IS IGNORED BUT YOU SHOULD TRY TO CLEAR IT FOR BEST
;	RESULTS IN THE FUTURE.
;
;	SAMPLE USAGE: 		.DB	FETCHREG,ATTACK	;GET LAST ATTACK
;				.DB	TABLE		;BRANCH BASED ON IT
;				.DRW	HURT0		;IF REG=0
;				.DRW	IGNORE		;IF REG=1
;				.DRW	BLOWUP		;IF REG=2
;				.DRW	PUKE		;IF REG=3
;
;
;45 =	<VICTIM> THIS COMMAND WILL MOVE THE EXECUTE POINTER IF THE LAST
;	PERSON YOU ATTACKED MATCHES THE VALUE YOU SPECIFY.  3 BYTES
;	FOLLOW THIS COMMAND:
;		1 WORD NEW POINTER
;		1 BYTE VALUE TO MATCH.
;46 =	<LOAD> THIS COMMAND WILL LOAD A VALUE FROM THE COMMON DATA
;	AREA INTO THE ENTITIES REGISTER.  THE COMMON DATA AREA HOLDS
;	64 BYTES.  IT IS USED FOR PRIZES, PASSING INFO ABOUT THE PROGRAM,
;	ETC.  A SEPERATE AREA OF COMMON DATA IS ALSO MAINTAINED.  THIS
;	AREA HOLDS A FULL WORD FOR EACH ENTITY.  YOU ACCESS IT BY SPECIFYING
;	<STATE> AS THE COMMON DATA RAM.  ALL OF THE COMMON DATA COMMANDS
;	GO INTO WORD MODE WHEN YOU SPECIFY <STATE>, OTHERWISE THEY OPERATE
;	BYTEWISE.   THIS COMMAND ZEROS THE HIGH BYTE OF YOUR REGISTER
;	IF A BYTE IS LOADED!!!!! USE <BLOAD> FOR A LOAD WITHOUT ZERO.
;
;	THE HIGH BYTE OF THE REGISTER IS CLEARED BY THIS COMMAND,
;	ONLY 1 BYTE IS LOADED UNLESS <STATE> IS SPECIFIED. 
;	1 BYTE FOLLOWS THIS COMMAND:
;		1 BYTE DATA TO BE FETCHED (0-63) OR <STATE> 
		.EQU	STATE,-1
;
;47 =	<STORE> THIS COMMAND WILL STORE THE ENTITIES REGISTER LOW BYTE INTO
;	A BYTE IN THE COMMON DATA AREA WHICH HOLDS 64 BYTES.  IF <STATE> IS
;	SPECIFIED A FULL WORD IS STORED. 1 BYTE FOLLOWS THIS COMMAND:
;		1 BYTE DATA LOCATION TO BE STORED INTO (0-63) OR <STATE> 
;48 =	<ADDDATA> THIS COMMAND ALLOWS YOU TO ADD THE REGISTER TO
;	A BYTE FROM THE COMMON DATA AREA.  THE RESULT IS STORED IN
;	THE REGISTER.  THE ADD WILL BE TO THE FULL WORD IN THE REGISTER
;	BUT ONLY A BYTE IS ADDED FROM THE COMMON DATA AREA RAM UNLESS
;	YOU SPECIFY <STATE> AS THE COMMON DATA AREA RAM.
;	1 BYTE FOLLOWS THIS COMMAND:
;		1 BYTE DATA LOCATION TO BE ADDED (0-31) OR <STATE> 
;49 =	<NOISE> THIS COMMAND ALLOWS YOU TO USE A SOUND CHANNEL THAT
;	IS SEPERATE FROM THE 4 USED BY THE MUSIC.  THIS SOUND CHANNEL
;	WILL BE LOST IF THE PLAYER PAUSES THE GAME.  ALSO, IT WILL
;	PROBABLY INTERRUPT GAME MUSIC AND SHOULD DEFFINATELY NOT
;	BE INTERRUPTED BY THE SOUND COMMAND.  HERE'S HOW YOU OUGHT TO
;	USE THIS COMMAND:  USE <SOUND> TO MAKE WORLD MUSIC.  THEN
;	PUT SHORT SOUND EFFECTS THAT ARE NOT CRITICAL INTO THIS
;	COMMAND.  KEEP IN MIND THAT ANOTHER <SOUND> COMMAND THAT
;	USES THIS VOICE AND IS RUN WHILE THIS ONE IS IN EFFECT 
;	WILL SUSPEND THIS ONE AND YOUR SOUND EFFECT MIGHT POP BACK 
;	WHEN THE MUSIC RUNS OUT.
;	IF YOU WANT TO <SOUND> AGAIN, THEN SILENCE THIS CHANNEL
;	FIRST FOR BEST SAFETY.  1 WORD FOLLOWS THIS COMMAND:
;		1 WORD NEW SOUND (0=SILENCE, -1 = NOCHANGE)
;
;	THIS COMMAND WILL TURN OFF ANY OLD NOISES AND THUS HAS "PRIORITY".
;	USE <LOWNOISE> FOR LOWER PRIORITY STUFF THAT SHOULDN'T INTERRUPT
;	SOMETHING IN EFFECT.
;
;	IF YOU WANT TO TIME SOME SOUND EFFECTS TO A SPECIFIC FRAME
;	OF AN ANIMATION, HERE ARE THE PAUSE DURATIONS IN NMI CYCLES
;	(SAME SPEED AS ANIMATION):
;			PAUSE+N16 = 8 CYCLES
;			PAUSE+N8 = 16 CYCLES
;			PAUSE+N4 = 32 CYCLES, ETC.

;4A =   <SETALT> SET ALTERNATE COUNTER.  THE COUNTER WILL TICK DOWN AT THE 
;	RATE OF 1/15 SECOND AND STOP AT 0. CLOCKPHASE CHANGES WILL ALSO
;	CHANGE THIS SPEED.  1 BYTE FOLLOWS THIS COMMAND:
;		1 BYTE COUNTER VALUE.  USE 0 <REGISTER> IF YOU WANT TO GET
;		  THE REGISTER.  IF YOU ACTUALLY WANTED TO CLEAR
;		  THE COUNTER, PUT 1 HERE AND IT WILL BE CLEAR NEXT CYCLE.
;4B =	<ALTCOUNT> MOVE EXECUTE POINTER IF ALT COUNTER IS BELOW OR EQUAL
;	TO VALUE.  3 BYTES FOLLOW THIS COMMAND:
;		1 WORD NEW POINTER
;		1 BYTE COUNTER VALUE TO BE BELOW.
;
;4C =	<FACE>  FACE SPECIFIED DIRECTION.  THE DEFAULT IS TO FACE TOWARDS
;	THE DIRECTION YOU ARE TRAVELING.  IF YOU SPECIFY FACING A DIRECTION,
;	IT BECOMES PERMANENT TILL YOU CHANGE IT.  WHILE YOU ARE LINKED
;	TO ANOTHER ENTITY, YOUR FACE BITS ARE IGNORED UNLESS YOU
;	ISSUE THE COMMAND <LINKFACE>.  1 BYTE FOLLOWS THIS COMMAND:
;		1 BYTE DIRECTION TO FACE:
;				<CURRENT> (H'80) TO MAKE IT STAY THE WAY IT 
;				     IS RIGHT NOW.
;				<TRAVELING> (H'40) TO MAKE IT FACE LEFT/RIGHT 
;				     ACCORDING TO DIRECTION IT IS TRAVELING.
;				<RISING> (H'20) TO MAKE IT TURN IT UPSIDE
;				     DOWN WHEN GOING UP AND RIGHTSIDE UP
;				     WHEN GOING DOWN.
;				<JOYDIR> (H'10) TO MAKE IT FACE LEFT/RIGHT
;				     ACCORDING TO THE LAST JOYSTICK PRESS
;				     OF LEFT OR RIGHT FOR THIS ENTITY.  IF
;				     THE ENTITY IS LINKED TO ANOTHER ENTITY
;				     AND DOES NOT HAVE A JOYSTICK ITSELF, IT
;				     WILL GET THE JOYSTICK BIT OF THE ENTITY
;				     TO WHICH IT IS LINKED.
;				<UP> (8) TO TURN THE SPRITE UPSIDE DOWN
;				<DOWN> (4) TO REVERT THE SPRITE TO THE WAY IT
;				     WAS DRAWN.
;				<LEFT> (2) TO MIRROR THE SPRITE AND LOCK IT
;				     INTO THAT STATE.
;				<RIGHT> (1) TO LOCK THE SPRITE INTO FACING 
;					THE DIRECTION IT WAS DRAWN.
;				<REGISTER> TO USE THE REGISTER'S CONTENTS.
;
;	YOU CAN "OR" THEM TOGETHER IN LOGICAL COMBINATIONS BUT YOU NEED TO
;	REMEMBER THAT THE HIGHEST VALUE BITS HAVE PRIORITY AND ONLY 1
;	BIT IS USED PER AXIS (X OR Y).  FOR INSTANCE:  JOYDIR|UP MAKES
;	IT FACE LEFT/RIGHT ACCORDING TO THE JOYSTICK IT IS ATTACHED TO
;	BUT ITS UPSIDE DOWN.  LEFT|UP IS MIRRORED AND INVERTED FROM THE
;	WAY YOU DREW IT.  CURRENT|JOYDIR|UP IS THE SAME AS CURRENT SINCE
;	THAT TAKES PRIORITY.  YOU MUST "OR" THEM IN A SINGLE COMMAND, THE
;	VALUE YOU SPECIFY REPLACES THE OLD STATE.  YOU CAN USE <REGISTER>
;	HERE IF YOU WANT.
;4D =	<BPALETTE> THIS COMMAND ALLOWS YOU TO CHANGE TO AN ENTIRELY NEW
;	BACKGROUND PALETTE OR TO RESTORE THE WORLD'S DEFAULT PALETTE.   
;	2 BYTES FOLLOWS THIS COMMAND:
;		1 WORD NAME OF NEW PALETTE OR -1 FOR WORLD DEFAULT PALETTE
;			OR <REGISTER>.
;4E =	<SPALETTE> THIS COMMAND ALLOWS YOU TO CHANGE TO AN ENTIRELY NEW
;	SPRITE PALETTE OR TO RESTORE THE WORLD'S DEFAULT PALETTE.   
;	2 BYTES FOLLOWS THIS COMMAND:
;		1 WORD NAME OF NEW PALETTE OR -1 FOR WORLD DEFAULT PALETTE
;			OR <REGISTER>.
;4F =	<SHAKE> THIS COMMAND ALLOWS YOU TO SPECIFY A SHAKE VALUE FOR
;	THE SCREEN OF FROM -7 TO +7.  THE SCREEN WILL SHIFT UP OR DOWN
;	ACCORDINGLY.  NEGATIVE VALUES SHIFT UP, POSITIVE DOWN.  BE SURE
;	TO RESTORE TO 0 WHEN DONE.   1 BYTE FOLLOWS THIS COMMAND:
;		1 BYTE SHAKE VALUE
;50 =	<LOWNOISE> THIS COMMAND IS THE SAME AS <NOISE> EXCEPT THAT IT
;	WON'T STOP A SOUND THAT IS ALREADY IN PROGRESS.  0 IS NOT SUPPORTED.
;	1 WORD FOLLOWS THIS COMMAND:
;		1 WORD NEW SOUND (0, -1 MEANS NO CHANGE)
;51 =	<XVISUAL> THIS COMMAND WILL MOVE THE EXECUTE POINTER IF AN
;	ENTITIES X LOCATION ON THE VISUAL SCREEN IS LESS THAN OR EQUAL TO
;	THE VALUE SPECIFIED.  THE CENTER OF THE ENTITY IS USED FOR THE X.
;	3 BYTES FOLLOW THIS COMMAND:
;		1 WORD NEW EXECUTE POINTER
;		1 BYTE X VALUE.
;52 =	<YVISUAL> THIS COMMAND WILL MOVE THE EXECUTE POINTER IF AN
;	ENTITIES Y LOCATION ON THE VISUAL SCREEN IS LESS THAN OR EQUAL TO
;	THE VALUE SPECIFIED.  VALUES WHERE YOUR ENTITY HAS
;	JUMPED ABOVE THE BACKGROUND ARE NEGATIVE AND THIS FUNCTION
;	DOES NOT ADJUST FOR THIS.   THE Y VISUAL LOCATION IS CONSIDERED
;	TO BE THE ENTITIES FEET SO IF YOUR ENTITY CANNOT JUMP SO HIGH THAT
;	HIS BOTTOM PIXEL ROW GOES ABOVE THE SCREEN (RECOMMENDED) YOU WON'T
;	HAVE NEGATIVE VALUES TROUBLES.   TRY SETTING THE WRAP PREVENTION
;	BIT IN THE ENTITY FLAGS TO EASE CHECKING. 3 BYTES FOLLOW THIS COMMAND:
;		1 WORD NEW EXECUTE POINTER
;		1 BYTE Y VALUE.
;53 =	<EQUAL> THIS COMMAND ALLOWS YOU TO COMPARE THE ENTITIES REGISTER
;	TO A VALUE AND MOVE THE EXECUTE POINTER IF THE REGISTER IS EQUAL
;	TO THIS VALUE.  4 BYTES FOLLOW THIS COMMAND:
;		1 WORD NEW POINTER
;		1 WORD COMPARE VALUE
;54 =	<REGINDEX> THIS COMMAND ALLOWS YOU TO INDEX INTO A ROM TABLE USING
;	THE REGISTER AND PICK A VALUE.  THE VALUE IS RETURNED IN THE
;	REGISTER.  THE FULL REGISTER IS USED AND A FULL WORD IS USED.
;	REGINDEX DOES NOT PICK AN ENTRY BASED ON YOUR VALUE.  IT SIMPLY
;	ADDS YOUR REGISTER TO THE TABLE POINTER.  THIS ALLOWS YOU TO
;	GET FROM A BYTE TABLE OR FROM A WORD TABLE.   IN OTHERWORDS,
;	IF YOU HAVE A WORD TABLE YOU MUST MULTIPLY YOUR REGISTER
;	BY 2 IF YOU WANTED AN ENTRY NUMBER.
;	2 BYTES FOLLOW THIS COMMAND:
;		1 WORD OFFSET OF TABLE IN ROM.
;
;55 =	<DISSCROLL> THIS COMMAND ALLOWS YOU TO DISABLE LEFT OR RIGHT SCROLLING.
;	USE THIS TO MAKE A GAME WHERE YOU CAN'T GO BACKWARDS IN THE WORLD.
;	WHEN YOU DISABLE SOMETHING, ITS ADDED TO WHATEVER ELSE IS DISABLED
;	AT THE TIME.
;   		1 BYTE SCROLLS TO DISABLE:
;			<LEFT> OR <RIGHT> OR <UP> OR <DOWN>
;
;	SAMPLE:		.DB	DISSCROLL,LEFT
;			.DB	DISSCROLL,LEFT|UP
;
;56 =	<ENASCROLL> THIS COMMAND ENABLES THE SCROLLS YOU DISABLED WITH
;	DISSCROLL.  1 BYTE FOLLOWS THIS COMMAND:
;		1 BYTE SCROLLS TO ENABLE.
;
;57 =	<SETCOL> THIS COMMAND ENABLES YOU TO OVERRIDE THE WORLD COLUMN
;	THAT WAS STORED WHEN AN ENTITY WAS LAUNCHED.  THE LAUNCHING WORLD
;	COLUMN OF THE COMMAND F0 OR F5 IS SAVED WHEN AN ENTITY IS LAUNCHED.  
;	YOU NEED THIS INFORMATION FOR SOME COMMANDS SUCH AS <ACTIVE>.  WHEN
;	AN ENTITY IS LAUNCHED MANUALLY (FROM ANOTHER ENTITY) ITS WORLD
;	COLUMN IS SET TO -1 BECAUSE THERE WAS NO ACTUAL WORLD COMMAND.
; 	BECAUSE OF THIS, YOU HAVE ONLY 1 IDENTIFICATION NUMBER POSSIBLE
;	AND IT WILL NOT BE UNIQUE IF OTHER ENTITIES HAVE LAUNCHED ENTITIES.
;	YOU CAN SET UP YOUR OWN UNIQUE WORLDCOLUMN NUMBER BY PUTTING
;	THIS COMMAND IN YOUR WAKEUP SEQUENCE.  BE SURE TO USE A WORLD
;	COLUMN NUMBER BEYOND THE LENGTH OF YOUR WORLD SO THAT WHEN THE
;	ENTITY IS KILLED NO MEMORY RAM WILL BE RESET. 
;	2 BYTES FOLLOW THIS COMMAND:
;		1 WORD WORLD COLUMN TO USE OR <REGISTER>
;
;58 =	<COMPAREDATA> THIS COMMAND ALLOWS YOU TO COMPARE THE REGISTER
;	TO ONE OF THE COMMON DATA AREA BYTES AND MOVE THE EXECUTE POINTER 
;	IF THE REGISTER IS ABOVE OR EQUAL TO THIS VALUE.  IF YOU SPECIFY
;	<STATE> A FULL WORD COMPARE IS MADE.  OTHERWISE ONLY THE
;	LOW BYTE OF THE REGISTER IS COMPARED TO A SINGLE BYTE IN COMMON
;	DATA AREA RAM.  3 BYTES FOLLOW THIS COMMAND:
;		1 BYTE DATA TO BE COMPARED TO (0-31) OR <STATE>
;		1 WORD NEW POINTER
;
;59 = 	<REGMOM> ADD REGISTER TO MOMENTUMS.  THIS COMMAND ALLOWS YOU TO ADD 
;	THE REGISTER TO THE X OR Y MOMENTUM.  THE SIGN OF YOUR VALUE WILL 
;	BE ADJUSTED ACCORDING TO THE TRACKING YOU HAVE SELECTED WITH 
;	XTRACK OR YTRACK IN CONJUNCTION WITH THE TARGET COMMAND.  ONLY
;	THE LOW BYTE OF THE REGISTER IS USED.  2 BYTES 
;	FOLLOW THIS COMMAND:
;		1 BYTE X AXIS SPECIFIER (<REGISTER> OR -1 FOR NO CHANGE).
;		1 BYTE Y AXIS SPECIFIER (<REGISTER> OR -1 FOR NO CHANGE).
;
;	SAMPLE USAGE:   .DB	REGMOM,REGISTER,-1    ;CHANGES X BUT NOT Y
;
;	NOTE: -1 IN THE REGISTER IS THE SAME AS NO CHANGE.
;
;5A =	<EXCHANGE> EXCHANGE REGISTER WITH COMMON DATA RAM.  ONLY THE 
;	LOW BYTE OF THE REGISTER IS EXCHANGED, THE HIGH IS UNCHANGED UNLESS
;	<STATE> IS SPECIFIED. 1 BYTE FOLLOWS THIS COMMAND:
;		1 BYTE DATA LOCATION TO BE EXCHANGED WITH OR <STATE> 
;5B =	<XOR> XOR REGISTER WITH FIXED VALUE.  2 BYTES FOLLOW THIS COMMAND:
;		1 WORD VALUE TO XOR TO THE REGISTER.
;5C =	<RGB> THIS COMMAND ALLOWS YOU TO SET THE RGB AND MONO BITS THAT
;	CONTROL THE PALETTES.  REMEMBER THAT THIS EFFECTS BOTH SPRITE
;	AND BACKGROUND PALETTES.  UNFORTUNATELY, TO RESTORE THE
;	UNCHANGED PALETTE SET YOU MUST LOAD THE REGISTER WITH 0 AND
;	CALL WITH REGISTER AS THE PARAMETER.  1 BYTE FOLLOWS THIS COMMAND:
;		1 BYTE VALUE TO USE FOR RGB AND MONO BITS:
			.EQU	RED,H'20
			.EQU	GREEN,H'40
			.EQU	BLUE,H'80
			.EQU	MONO,H'01
;			OR <REGISTER> TO USE THE REGISTER'S CONTENTS.
;
;	SAMPLE USAGES:	.DB	RGB,REGISTER	;REGISTER'S CONTENTS
;			.DB	RGB,RED|BLUE	;RED WITH BLUE SET
;5D =	<SETBEHAVIOR> THIS COMMAND ALLOWS YOU TO SET THE INDIVIDUAL 
;	BEHAVIOR BITS.  THESE BITS CAN BE TESTED WITH THE <IFBEHAVIOR> 
;	COMMAND. THE BEHAVIOR BIT NAMES ARE JUST EQUATES.  THE BEHAVIOR BYTE
;	CAN ACCOMODATE 8 OF THEM.  THE VALUES HERE ARE JUST SUGGESTIONS.
;	1 BYTE FOLLOWS THIS COMMAND:
;		1 BYTE BEHAVIOR BIT TO SET OR <REGISTER>:
			.EQU	INTELLIGENT,H'01 
			.EQU	SHY,H'02
			.EQU	WEAK,H'04
			.EQU	HIJUMPER,H'08
			.EQU	FAST,H'10
			.EQU	MAD,H'20
			.EQU	DYING,H'40
			.EQU	OPTION1,H'80

;IF YOU WOULD LIKE MORE GENERIC BITS TRY THESE:

			.EQU	OPT1,H'01 
			.EQU	OPT2,H'02 
			.EQU	OPT3,H'04 
			.EQU	OPT4,H'08 
			.EQU	OPT5,H'10 
			.EQU	OPT6,H'20 
			.EQU	OPT7,H'40 
			.EQU	OPT8,H'80 

;5E =	<RESETBEHAVIOR> THIS COMMAND ALLOWS YOU TO RESET THE INDIVIDUAL
;	BEHAVIOR BITS.  1 BYTE FOLLOWS THIS COMMAND:
;		1 BYTE BEHAVIOR BIT TO RESET
;		YOU CAN USE <REGISTER> TO USE THE REGISTER'S CONTENTS.
;
;5F =	<IFBEHAVIOR>  IF BEHAVIOR BIT IS SET, MOVE TO NEW EXECUTE POINTER.
;	3 BYTES FOLLOWS THIS COMMAND:
;		1 WORD NEW EXECUTE POINTER
;		1 BYTE BEHAVIOR BIT(S) TO TEST FOR
;60 =	<IFNBEHAVIOR> IF BEHAVIOR BIT IS NOT SET, MOVE TO NEW EXECUTE
;	POINTER.  3 BYTES FOLLOW:
;		1 WORD NEW EXECUTE POINTER
;		1 BYTE BEHAVIOR BIT(S) TO TEST FOR
;61 =	<CREATE> ABSOLUTE LAUNCH OF AN ENTITY.  USE THIS COMMAND TO 
;	CAUSE ENTITIES INDEPENDANT FROM THIS ENTITY TO BE CREATED ON
;	SCREEN.  THE LAUNCH POINT IS ABSOLUTE, NOT RELATIVE TO THIS
;	ENTITY.  4 BYTES FOLLOW THIS COMMAND:
;		1 BYTE ENTITY NUMBER TO LAUNCH.  USE 0 <REGISTER> TO USE
;		  THE VALUE IN THE ENTITIES REGISTER.  THIS
;		  MEANS YOU CAN'T LAUNCH ENTITY 0 WITH THIS COMMAND!
;		1 BYTE LAUNCH X OFFSET ON SCREEN.
;		1 BYTE LAUNCH Y OFFSET ON SCREEN
;		1 BYTE VALUE TO PLACE INTO PARAM2 OF THAT ENTITY.
;62 = 	<STAIR> MOVE EXECUTE POINTER IF THERE IS A STAIR IN FRONT OF YOU.
;	A STAIR IS DETECTED IF YOUR ENTITY CANNOT BE MOVED FORWARD BY
;	8 PIXELS IN HIS TRAVEL DIRECTION WITHOUT HITTING A SOLID BUT
;	HE COULD DO SO IF HE WERE TO JUMP UP.  THE SOFTWARE WILL TEST
;	WHAT WOULD HAPPEN IF YOUR ENTITY MOVED FORWARD 8 PIXELS.  IF
;	HE WOULD BE ON TOP OF SOLID, THE SECOND TEST WILL BE MADE.
;	THE SECOND TEST IS TO MOVE HIM FORWARD BY 8 PIXELS AS BEFORE
;	BUT ALSO MOVE HIM UPWARDS BY THE NUMBER OF 8 PIXEL ROWS (TILES)
;	YOU SPECIFY IN THE 1 BYTE NUMBER OF ROWS IN THE COMMAND.  
;	THIS TIME THE MOVEMENT MUST BE SUCCESSFULLY ON TOP OF A SAFE
;	(NONSOLID) AREA.  IF BOTH TESTS PASS THE EXECUTE POINTER IS MOVED.
;	OTHERWISE EXECUTION CONTINUES WITH THE NEXT INSTRUCTION.
;	3 BYTES FOLLOW THIS COMMAND:
;		1 WORD NEW POINTER
;		1 BYTE NUMBER OF ROWS TO CHECK ABOVE THE ENEMIES FEET FOR
;		  THE TOP OF A POTENTIAL STAIR.
;
;63 =	<ANIMATION> THIS COMMAND ALLOWS YOU TO PICK THE ANIMATION UP FROM
;	ONE OF THE ENTITIES ENTRIES (EWALK, ESTAND, ETC.) WITHOUT ACTIVATING
;	THE TABLE OF MOVEMENTS USED IN THAT ENTRY.  IT IS BEST USED FOR
;	SHARED CODE THAT CAN'T USE THE SEQUENCE COMMAND TO DO THE SAME
;	BECAUSE IT HAS TO PICK FROM THAT ENTITIES TABLE.  YOU CAN ALSO
;	USE THIS COMMAND TO PICK UP SPECIAL ANIMATIONS STORED DIRECTLY
;	ABOVE THE ENTITIES ANIMATION/MOVEMENT LIST.  IN THIS CASE,
;	ONLY THE ANIMATION IS SWITCHED AND YOUR CURRENT DAMAGE
;	FLAGS ARE UNCHANGED.   2 BYTES FOLLOW
;	THIS COMMAND:
;		1 BYTE ANIMATION INDEX TO PICK (EWAKE, ETC)
;		1 BYTE FLAG:
;			1 TO NOT USE THE DAMAGE FLAGS FOR THAT ENTRY
;			2 TO USE THE DAMAGE FLAGS FOR THAT ENTRY.
;			<RESERVE> TO USE THE VALUE SPECIFIED IN THE
;			ANIMATION INDEX AS A BACKWARDS INDEX ABOVE YOUR
;			TABLE.  IN THIS CASE YOU WILL NOT BE USING THE
;			DAMAGE FLAGS.  THE NUMBER YOU SPECIFY IN THE FIRST
;			BYTE WILL BE SUBTRACTED FROM THE START OF YOUR
;			TABLE AND THAT WILL BE EXPECTED TO BE THE NAME
;			OF YOUR ANIMATION.  THE ANIMATION NAME MUST
;			BE FOLLOWED BY THE INIT OPTIONS BYTE.  THUS ITS
;			3 BYTES PER ENTRY ABOVE YOUR TABLE.
;
;	EXAMPLE:		.DB	ANIMATION,EHURT,2	;GETS COWCHEW
;				.DB	ANIMATION,3,RESERVE	;GETS COWHOPS
;				.DB	ANIMATION,6,RESERVE	;GETS COWFARTS
;		.DRW	COWFARTS
;		.DB	0
;		.DRW	COWHOPS		;THESE ARE RESERVE ANIMATIONS
;		.DB	H'23
;      	COW:				;NORMAL ANIMATION/MOVEMENT TABLE.
;		.DRW  	COWWALK		;WAKEUP
;		.DRW	COWWAKE		;THE WAKEUP SETS BEHAVIOR BITS FOR THIS ENTITY
;		.DB	H'40,-1
;		.DB	0,0
;		.DB	0
;		.DRW	COWCHEW		;HURT 
;		.DRW	ANHURT
;		.DB	H'40,-1
;		.DB	0,0
;		.DB	0



;
;64 =   <CHEAT> THIS COMMAND ALLOWS YOU TO ENABLE OR DISABLE CHEAT MODE.
;	IF ENABLED B+SELECT ON THE FIRST JOYSTICK GOES TO THE NEXT WORLD
;	UP TO THE LIMIT SPECIFIED IN USE_BACK.  YOU NEED TO FINISH YOUR
;	GAME BY LOOKING FOR SOME COMBINATION AT SOME POINT TO ENABLE THIS.
;	CHEATER MODE GOES DIRECTLY TO WORLDS POSSIBLY SKIPPING SOME VITAL
;	LOGIC IN YOUR CODE.  USE <IFNCHEAT> TO CATCH THE CHEATERS AS THEY
;	ENTER EACH WORLD. 1 BYTE FOLLOWS THIS COMMAND:
;		1 BYTE <OFF> TO DISABLE, <ON> TO ENABLE
;
;	SAMPLE:		.DB	CHEAT,ON	;ENABLES CHEAT MODE
;			.DB	CHEAT,OFF	;DISABLES CHEAT MODE
;
;65 =	<RESETFRICTION> THIS COMMAND ALLOWS YOU TO RESET THE X OR Y AXIS
;	FRICTION COUNTER WITHOUT CHANGING THE MOMENTUM.  YOU CAN EMBED
;	THESE PERIODICALLY IN YOUR COMMAND STREAM TO PRESERVE AN UNKNOWN
;	AMOUNT OF MOMENTUM IN CASES WHERE CODE IS SHARED.  OTHERWISE
;	THE FRICTION WILL EVENTUALLY KICK IN AND ZERO MOMENTUM.  2 BYTES
;	FOLLOW THIS COMMAND:
;		1 BYTE X FRICTION FLAG (0=LEAVE ALONE, 1=RESET FRICTION)
;		1 BYTE Y FRICTION FLAG (0=LEAVE ALONE, 1=RESET)
;
;66 =	<FLOOR> THIS COMMAND ALLOWS YOU TO CHECK FOR A FLOOR BELOW YOU
;	WITHIN A CERTAIN DISTANCE AND TO BRANCH IF ONE IS FOUND.  IT
;	CHECKS AT INTERVALS OF 8 PIXELS NOT COUNTING THE PLACE WHERE
;	YOU ARE CURRENTLY.
;	3 BYTES FOLLOW THIS COMMAND:
;		1 WORD NEW POINTER
;		1 BYTE NUMBER OF ROWS TO CHECK BELOW THE ENEMIES FEET.
;		BE CAREFUL, IT USES LOTS OF PROCESSOR POWER.
;
;67 =	<LINK> THIS COMMAND ALLOWS YOU TO LINK YOUR ENTITY TO ANOTHER
;	ENTITY.  YOU SPECIFY THE X AND Y DISPLACEMENT RELATIVE TO THE
;	ENTITIES UPPER LEFT CORNER.  THESE VALUES ARE INVERTED IF THE
;	ENTITY IS MIRRORED OR INVERTED.  THIS COMMAND IS USED FOR
;	"LIMB EXTENSIONS" OR TO THROW WEAPONS CORRECTLY INDEPENDANT
;	OF THE DIRECTION THE ENTITY IS FACING.  YOUR ENTITY WILL ALSO
;	BE MIRRORED OR INVERTED IF THE ENTITY IT IS LINKED TO IS INVERTED.
;	ONCE LINKED, THE LINK IS PERMANENT UNTIL AN UNLINK COMMAND IS
;	ENCOUNTERED.  THE LAUNCHING WORLD COLUMN OR ID IS ONLY CHECKED
;	AT THE TIME THE LINK COMMAND IS ENCOUNTERED.  FROM THEN ON YOUR
;	ENTITY STAYS LINKED TO THAT ENTITY EVEN IF THAT ENTITY CHANGES ITS
;	WORLD COLUMN NUMBER.  IF THE LINKED TO ENTITY DIES, YOUR ENTITY
;	WILL AUTOMATICALLY BE UNLINKED.  
;	DURING A LINK, YOUR COMMAND TABLE IS AUTOMATICALLY EXECUTED BUT
;	ALL MOTION COMMANDS WILL HAVE NO EFFECT ON FINAL SCREEN PLACEMENT.
;	IF THE ENTITY BECOMES UNLINKED BECAUSE THE ORIGINAL ENTITY IS KILLED,
;	THESE COMMANDS WILL SUDDENLY OPERATE.  USE THIS FOR A MULTI-LIMBED
;	MONSTER THAT BREAKES UP INTO DEADLY SMART FRAGMENTS.  OR USE THE
;	<ACTIVE> COMMAND TO MAKE THE LIMB GO AWAY TOO.  
;
;	BECAUSE THE NINTENDO VERSION HAS NO MORE RAM AVAILABLE, THERE IS
;	ONE WEIRD QUIRK OF LINKED ENTITIES.  IF YOU SPECIFY FRICTION 
;	CHANGES DURING LINK THEY WILL BE IGNORED AND WHEN THE ENTITY IS
;	UNLINKED THE FRICTION WILL BE RESTORED TO ITS DEFAULT VALUE.
;	ALL OTHER COMMANDS FUNCTION CORRECTLY FOR A LINKED ENTITY EXCEPT
;	THAT IT WILL NOT MOVE OTHER THAN IN CONCERT WITH THE ONE TO WHOM
;	IT IS LINKED.  YOU CAN SET MOMENTUM WHILE LINKED AND THEN UNLINK
;	IT TO RELEASE IT.  JUST REMEMBER NOT TO ISSUE ANY FRICTION COMMANDS
;	DURING LINK AND ANY FRICTION VALUE CHANGES MUST BE ISSUED AFTER
;	UNLINK.
;
;		5 BYTES FOLLOW THIS COMMAND:
;		1 BYTE OFFSET RELATIVE TO ITS X OR
;			<NOCHANGE> (-1) FOR THE CURRENT OFFSET
;			<CENTERED> (H'80) TO STAY CENTERED ON THE X AXIS 
;			  WITH THE SPRITE YOU ARE LINKED TO.
;			(<REGISTER> NOT SUPPORTED)
;		1 BYTE OFFSET RELATIVE TO ITS Y OR
;			<NOCHANGE> (-1) FOR THE CURRENT OFFSET
;			(<REGISTER> NOT SUPPORTED)
;		1 BYTE IDENTIFICATION TYPE OF THE ENTITY (<COLUMN> OR <ID>).
;			YOU CAN SPECIFY <ATTACKER> FOR THE LAST ATTACKER
;			AGAINST THIS ENTITY (THEN THE WORD AFTERWARDS IS
;			NOT USED BUT MUST BE PRESENT).
;		1 WORD NUMBER TO MATCH.  IF FROM ENTITYTAB, ONLY LOW BYTE
;		  IS USED.  IF WORLD COLUMN, FULL WORD.  YOU CAN ALSO SPECIFY
;		  <REGISTER> FOR THE VALUE IN THE REGISTER (ONLY PROVIDES
;		  1 BYTE RANGE, TOP BYTE IS ZEROED). THIS MEANS YOU CAN'T 
;		  MATCH 0 UNLESS YOU LOAD THE REGISTER WITH 0.
;
;	THIS COMMAND WILL TERMINATE AN INSTRUCTIONS COMMAND (TO ALLOW 
;	IMMEDIATE SPRITE POSITIONING).
;
;68 = <UNLINK> THIS COMMAND CANCELS COMMAND 67.  BE CAREFUL TO PUT ALL
;	FRICTION ZEROING COMMANDS AFTER THE UNLINK SINCE THIS COMMAND
;	IS IGNORED UNTIL THEM (REUSE OF INTERNAL MEMORY!).
;
;69 =	<SPAWN> LAUNCH LINKED ENTITY.  USE THIS COMMAND TO 
;	LAUNCH AN ENTITY THAT IS IMMEDIATLY LINKED TO YOURSELF.  THIS
;	IS THE SAME AS USING A LAUNCH COMMAND AND HAVING THAT ENTITY
;	DO A LINK FOR ITS FIRST INSTRUCTION EXCEPT THAT THE INTERMEDIATE
;	WRONG VISUAL POSITION IS SKIPPED.
;	4 BYTES FOLLOW THIS COMMAND:
;		1 BYTE ENTITY NUMBER TO LAUNCH.  USE 0 <REGISTER> TO USE
;		  THE VALUE IN THE ENTITIES REGISTER.  THIS
;		  MEANS YOU CAN'T LAUNCH ENTITY 0 WITH THIS COMMAND!
;		1 BYTE X RELATIVE LINK OFFSET SAME AS FOR COMMAND 67
;		1 BYTE Y RELATIVE LINK OFFSET SAME AS FOR COMMAND 67
;		1 BYTE VALUE TO PLACE INTO PARAM2 OF THAT ENTITY.
;6A =	<HALFFREQ> EXECUTE ENTITY HALF AS FREQUENTLY. THE ENTITY IS
;	UPDATED AND HIS EXECUTION TABLE IS RUN AT HALF SPEED.  DON'T USE
;	THIS FOR LINKED ENTITIES BECAUSE THE EXECUTION OF HALF FREQUENCY
;	ENTITIES IS STAGGERED TO PRESERVE PROCESSOR POWER AND THEY
;	WILL NOT VISUALLY KEEP UP WITH EACH OTHER AT HALF SPEED. 
;
;	WHEN RUNNING HALF SPEED, THE COUNTERS ALSO GO HALF SPEED BUT
;	THE ANIMATION ITSELF (FROM THE DRAWING PROGRAM) RUNS FULL SPEED.
;	1 BYTE FOLLOWS THIS COMMAND:
;		1 BYTE FLAG.  <OFF> OR <ON>
;6B =	<IFLINKED> MOVE EXECUTE POINTER IF YOU ARE LINKED TO
;	ANOTHER ENTITY.  2 BYTES FOLLOW THIS
;	COMMAND:
;		1 WORD NEW EXECUTE POINTER
;6C =	<RELINK> THIS COMMAND ALLOWS YOU TO CHANGE THE RELATIVE X AND
;	Y OFFSETS OF A PREVIOUS LINK.  NO CHECK IS MADE TO MAKE SURE YOU
;	ACTUALLY WERE LINKED SO BE CAREFUL. YOU CAN SPECIFY NO CHANGE
;	AND USING THE REGISTER WITH THIS COMMAND.  TO SET BOTH WITH
;	2 REGISTER VALUES YOU WILL HAVE TO USE 2 OF THESE COMMANDS.
;	AFTER ISSUING THIS COMMAND, YOUR INSTRUCTION EXECUTION WILL
;	END UNTIL THE NEXT CYCLE.
;
;	2 BYTES FOLLOW THIS COMMAND:
;		1 BYTE NEW X OFFSET OR <REGISTER> FOR THE REGISTER OR
;			-1 FOR NO CHANGE.  NOTE THAT YOU CANNOT SPECIFY
;			A VALUE OF 0 SINCE THIS IS THE VALUE OF THE
;			REGISTER EQUATE.
;		1 BYTE NEW Y OFFSET OR <REGISTER> FOR THE REGISTER OR
;			-1 FOR NO CHANGE.  YOU CANNOT SPECIFY 0.
;
;	THIS COMMAND WILL TERMINATE AN INSTRUCTIONS COMMAND (TO ALLOW 
;	IMMEDIATE SPRITE POSITIONING).
;
;6D =	<TOPSTAT> THIS COMMAND ALLOWS YOU TO DISPLAY A TOP OF SCREEN STATUS
;	BAR.  YOU CAN CONTROL THE NUMBER OF ROWS IN THAT STATUS BAR, WHERE
;	THE STATUS BAR BEGINS IN MEMORY, AND ALSO HOW MUCH BACKGROUND IT
;	OVERLAYS.  THE NUMBER OF ROWS DISPLAYED SHOULD BE ONE MORE
;	THAN WHAT YOU ACTUALLY WANT TO USE BECAUSE MOST TVs CROP OFF THE 
;	TOP 1.4 ROWS.  
;
;	THE STATUS BAR REGION (EVERYTHING BELOW THE HEIGHT OF YOUR 
;	CURRENT BACKGROUND) IS CLEARED EACH TIME A NEW WORLD IS ACTIVATED.
;	THUS YOU MUST REPAINT YOUR ENTIRE STATUS LINE EACH TIME A WORLD
;	COMES UP.
;
;	4 BYTES ARE NEEDED TO DETERMINE THE STATUS BAR:  1 BYTE
;	SPECIFIES HOW MANY PIXEL ROWS UP FROM THE BOTTOM OF PAGE 2 VIDEO
;	TO BEGIN THE STATUS BAR.  THE SECOND BYTE SPECIFIES
;	HOW MANY PIXEL ROWS TO DISPLAY FROM THAT AREA BEFORE BEGINNING THE
;	BACKGROUND. THE THIRD SPECIFIES HOW MANY PIXEL ROWS TO CUT OFF
;	FROM THE TOP OF THE BACKGROUND. IT MUST BE A MULTIPLE OF
;	8 PIXELS.  THE FORTH SPECIFIES THE CHARACTER SET BANK TO USE. 
;
;	FOR NOW, THE SECOND AND THIRD BYTES MUST BE SET EQUAL BECAUSE WE
;	HAVE NOT FIGURED OUT HOW TO SCROLL Y IN THE MIDDLE OF PAINTING
;	THE SCREEN.  ALSO, IF YOUR SPRITES MOVE UP INTO THE STATUS LINE
;	AREA YOU CANNOT HAVE A DIFFERENT CHARACTER SET BANK BECAUSE THEY
;	WILL CHANGE TO USE THE NEW BANK.  SET THIS BANK THE SAME AS YOUR
;	GAME BANK IF YOU HAVE SPRITES THAT CAN GO THAT HIGH (THIS MEANS
;	YOUR STATUS LINE CHARACTERS MUST BE COMMON TO ALL BANKS).
;
;	TO USE THE STATUS BAR, YOU MUST HAVE A STATUS BAR CHARACTER AVAILABLE
;	WHICH HAS A SOLID LINE IN ITS BOTTOMMOST ROW.  IF YOU ARE RUNNING
;	2 HIGH MODE IT MUST HAVE A BLANK CHARACTER UNDER THIS IN ALL BANKS.
;	THE LOGIC WILL PLACE THIS CHARACTER VALUE AT THE END OF YOUR STATUS
;	BAR AREA (LAST CHAR IN BOTTOM MOST ROW).  THEN IT WILL MANUALLY
;	SET SPRITE 0 TO THIS SAME CHARACTER VALUE AND PUT IT ON TOP. THE
;	EQUATES STATCHAR AND STATSPRITE AT THE ASSEMBLY TOP CONTROL THIS.
;
;
;	4 BYTES FOLLOW THIS COMMAND:
;		1 BYTE PIXEL ROWS UP FROM BOTTOM OF PAGE 2 VIDEO TO START
;		   THE STATUS BAR DISPLAY (MINUMUM IS 9 IF YOU WANT TO HAVE
;		   ONE).  
;		1 BYTE PIXEL ROWS TO DISPLAY IN THE STATUS BAR (MINIMUM IS 9)
;		1 BYTE PIXEL ROWS TO CUTOFF FROM THE BACKGROUND
;		1 BYTE CHARACTER SET BANK TO USE FOR THE STATUS BAR.   USE
;		   -1 TO USE THE SAME ONE AS THE BACKGROUND.
;
;	TO DISABLE TOP OF SCREEN STATUS BAR, SET ALL 4 BYTES TO 0.
;
;	SAMPLE USAGE:	
;			.DB	TOPSTAT,38,38,0,15	;2 HIGH STATUS BAR
;							;IN VIDEO BANK 7 HI
;			.DB	TOPSTAT,0,0,0,0		;DISABLE TOP OF SCREEN
;							;STATUS BAR SO WE
;							;CAN SCROLL VERTICALLY.
							
;	AT THE CURRENT TIME, ISSUING A TOPSTAT COMMAND WHILE A WORLD
;	IS UP WILL NOT ADJUST THE SPRITES ALREADY ON SCREEN.  YOU WOULD
;	NEED TO DO THIS IF YOU WANTED TO ACTUALLY SHIFT THE BACKGROUND
;	UP OR DOWN BUT NOT IF YOU JUST WANTED TO PULL DOWN A STATUS BAR.
;	MAKE CHANGES TO THE SIZE OF THE STATUS BAR BEFORE YOU ACTIVATE THE
;	WORLD (JUST BEFORE YOU ISSUE THE WORLD,XX COMMAND).
;
;	IF YOU WANT TO MIX WORLDS THAT HAVE NO TOP OF SCREEN STATUS BAR
;	WITH THOSE THAT HAVE ONE, YOU MAY HAVE TO MAKE A FAKE SPRITE TO
;	TAKE UP SPRITE 0 WHEN IN THE WORLDS WITHOUT TOP OF SCREEN STATUS
;	BAR.  SPRITE #0 IS NEEDED FOR A TOP OF SCREEN STATUS BAR.  IF YOU
;	KEEP ENTITIES ALIVE WHEN YOU CHANGE WORLDS, YOU WILL HAVE TO 
;	INSURE THE AVAILABILITY OF SPRITE 0 MANUALLY.
;
;6E =	<WRITEVID>  THIS COMMAND ALLOWS YOU TO WRITE A STRING OF CHARACTERS
;	FROM MEMORY INTO THE STATUS BAR AREA.  YOU SPECIFY THE LOCATION OF
;	DATA IN MEMORY, THE ROW, COLUMN, AND LENGTH TO WRITE.  ROW 0 OF
;	YOUR STATUS LINE MAY NOT BE ALL VISIBLE DEPENDING ON WHETHER YOUR
;	STATUS BAR HEIGHT WAS A MULTIPLE OF 8.  THE MAXIMUM YOU CAN WRITE
;	OUT IN A SINGLE COMMAND IS 32.  YOUR WRITE MUST NOT LAPSE OVER
;	INTO THE NEXT ROW.  THE WRITE IS LIMITED TO 32 DUE TO RAM LIMITATIONS
;	AND THE NECESSITY TO ALLOW THE DATA TO BE IN THE OTHER ROM PAGE.

;	THIS COMMAND WILL HALT YOUR EXECUTION UNTIL IT CAN BE COMPLETED.
;	USUALLY THIS WILL BE IMMEDIATE IF THIS IS A SINGLE THREADED
;	STATUS BAR WRITE BUT IF OTHER LEVELS WRITE TO THE STATUS BAR
;	YOURS MAY HAVE TO WAIT.
;
;	FOR SAFETY, IF YOU ARE GOING TO FOLLOW ANY VIDEO COMMAND WITH
;	A WORLD REQUEST BE SURE TO PUT A DELAY OR AT LEAST 1 MORE
;	INSTRUCTION BEFORE THE WORLD REQUEST OR ELSE YOUR VIDEO
;	ACCESS COULD TAKE PLACE AFTER THE WORLD WAS PAINTED.
;
;	6 BYTES FOLLOW THIS COMMAND:
;		1 WORD LOCATION OF DATA TO WRITE IN MEMORY
;		1 BYTE ROW (Y) TO WRITE IT TO
;		1 BYTE COLUMN (X) TO WRITE IT TO
;		1 BYTE VIDEO PAGE (0 OR 1) OR <STATVID> FOR STATUS BAR
			.EQU	STATVID,-1
;		1 BYTE LENGTH TO WRITE (32 MAX)
;
;	TO USE THIS ROUTINE TO PUT UP ASCII MESSAGES, YOU MUST POINT
;	IT TO A .DB STATEMENT IN MEMORY THAT HAS THE ASCII VALUES FROM
;	YOUR CHARACTER SET.  THE DEFAULT FOR INHOUSE GAMES IS THAT 0-9
;	ARE BINARY 0-9 AND "A" STARTS AT 10.  THE FOLLOWING BASIC
;	PROGRAM CAN HELP YOU CONVERT ASCII TO THIS FORMAT.  IT TAKES
;	AN INPUT FILE OF "TEXTFILE" AND MAKES MESSAGES.ASM:
;
;	10 OPEN "TEXTFILE" FOR INPUT AS #1
;	20 OPEN "MESSAGES.ASM" FOR OUTPUT AS #2
;	30 INPUT #1,A$
;	40 PRINT #2,";";A$:PRINT #2,".DB ";
;	50 X=LEN(A$)
;	60 FOR Y=1 TO X
;	70 B$=MID$(A$,Y,1)
;	80 IF B$=" " THEN PRINT #2,"64 ";:GOTO 100
;	90 PRINT #2,ASC(B$)-55;
;	100 IF Y=X THEN 110 ELSE PRINT #2,",";
;	110 NEXT Y
;	120 PRINT #2,"":PRINT #2,""
;	130 IF EOF(1) GOTO 140 ELSE GOTO 30
;	140 CLOSE
;	150 SYSTEM
;

;6F =	<FILLVID>  THIS COMMAND ALLOWS YOU TO FILL AN AREA OF THE STATUS
;	BAR OR VIDEO MEMORY WITH A GIVEN CHARACTER. YOU SPECIFY THE
;	ROW, COLUMN, DATA AND LENGTH TO WRITE.  THE MAXIMUM YOU CAN WRITE 
;	IN A SINGLE COMMAND IS 64.
;
;	THIS COMMAND WILL HALT YOUR EXECUTION UNTIL IT CAN BE COMPLETED.
;	USUALLY THIS WILL BE IMMEDIATE IF THIS IS SINGLE THREADED
;	WRITE LOGIC BUT IF OTHER LEVELS WRITE TO THE VIDEO OR STATUS BAR
;	YOURS MAY HAVE TO WAIT.  
;
;	FOR SAFETY, IF YOU ARE GOING TO FOLLOW ANY VIDEO COMMAND WITH
;	A WORLD REQUEST BE SURE TO PUT A DELAY OR AT LEAST 1 MORE
;	INSTRUCTION BEFORE THE WORLD REQUEST OR ELSE YOUR VIDEO
;	ACCESS COULD TAKE PLACE AFTER THE WORLD WAS PAINTED.
;
;	5 BYTES FOLLOW THIS COMMAND:
;		1 BYTE ROW TO WRITE IT TO
;		1 BYTE COLUMN TO WRITE IT TO
;		1 BYTE DATA TO WRITE OUT
;		1 BYTE VIDEO PAGE (0 OR 1) OR STATVID FOR STATUS BAR
;		1 BYTE LENGTH TO WRITE
;
;70 =	<SETSTATPAL> THIS COMMAND ALLOWS YOU TO SPECIFY THE PALETTE SET
;	TO BE USED AT A GIVEN SET OF 4 ROWS ON THE STATUS BAR.  THE
;	NINTENDO HARDWARE SPECIFIES PALETTE INFO IN A GROUP OF 8
;	BYTES WHICH CONTROLS 32 WIDE BY 4 HIGH TEXT CELLS (8x8 PIXELS EACH).
;	EACH BYTE IS NIBBLE ORIENTED.  THE BOTTOM MOST 2 ROWS OF
;	YOUR STATUS BAR IS THE START OF A NEW SET OF 4 ROWS BUT
;	THE EXTRA 2 ROWS DO NOT EXIST.  THUS IF YOUR STATUS BAR WERE
;	6 HIGH YOU WOULD NEED TO MAKE 2 SPECIFICATIONS WITH THIS COMMAND
;	TO GET ALL 6 ROWS.  THE FIRST MIGHT SET THE FIRST 4 ROWS AND
;	THE SECOND SETSTATPAL COMMAND MIGHT SET THE BOTTOM 2 WITH THE EXTRA
;	DATA FOR ANOTHER 2 ROWS BEING UNUSED.  THIS COMMAND HAS A FIXED
;	LENGTH AND SPECIFIES THE FULL 8 BYTES THAT CONTROL 4 FULL ROWS.
;	THE ORGANIZATION OF EACH BYTE IS EXPLAINED IN THE MAP BELOW.
;	THE BYTE IS SHOWN AS 8 BITS BUT EACH SET OF 2 BITS IS ASSIGNED
;	A NUMBER FROM 0-3.  THE 33 MEANS THAT THOSE 2 BITS CONTROL AREA
;	3 IN THE ROW MAP SHOWN:
;
;	BYTE = 33221100		RESULT ON THE 4 ROWS:  0011
;						       0011
;						       2233
;						       2233
;
;	THE NEXT BYTE CONTROLS THE DATA ON THE 4 ROWS IMMEDIATLY TO
;	THE RIGHT OF THAT BYTES DATA.  SINCE EACH REGION IS 4 WIDE IT
;	TAKES 8 BYTES TO CONTROL THE ENTIRE 32 WIDE REGION.  THE VALUE
;	IN THE 2 BIT NIBBLE AT THAT POSITION CONTROLS WHICH PALETTE IS USED.
;	FOR INSTANCE, IF NIBBLETTE 33 WERE SET TO 01 BINARY THEN THE
;	REGION 2 ROWS DOWN AND 2 COLUMNS TO THE RIGHT WOULD USE THE
;	SECOND SET OF PALETTE COLORS FROM THE BACKGROUND'S 4 SETS.  THIS
;	CORRESPONDS TO THE SECOND SET OF 4 PALETTE COLORS IN YOUR DRAWING
;	PROGRAM FOR THAT BACKGROUND.
;
;	THIS COMMAND IS ALREADY VERY MACHINE SPECIFIC SO THE COMMAND
;	ITSELF REQUIRES YOU TO MAKE YOUR OWN CALCULATIONS ABOUT WHERE
;	THE DATA GOES.  RATHER THAN NUMBER ROWS FROM THE TOP DOWN, YOU
;	MUST SPECIFY GROUPS OF 4 ROWS TO SET FROM THE BOTTOM UP WITH THE
;	BOTTOM MOST ROW CONTROLLING ONLY 2.  THUS IN THE ROW BYTE
;	FOR THIS COMMAND SPECIFYING 0 WOULD SET THE PALETTE FOR THE
;	BOTTOMMOST 2 ROWS OF YOUR STATUS LINE.  SPECIFYING 1 WILL SET
;	THE NEXT 4 ROWS UP.  YOU MUST DO THIS EVEN IF YOU ARE ONLY
;	USING ANOTHER 2 OF THEM.  YOU CAN GO ALL THE WAY TO THE TOP
;	OF THE PALETTE AREA WHICH IS EQUAL TO A ROW INDEX HERE OF 7
;	BUT IT IS UNLIKELY YOUR STATUS LINE WILL GO ABOVE INDEX 2.
;
;	9 BYTES FOLLOW THIS COMMAND:
;		1 BYTE 4 ROW SET UP FROM THE BOTTOM TO SET (0,1,2, ETC.)
;		8 BYTES OF DATA TO WRITE OUT
;
;71 =	<RDIVIDE> THIS COMMAND ALLOWS YOU TO DIVIDE YOUR REGISTER BY
;	A VALUE IN COMMON DATA AREA RAM.  THE RESULT IS RETURNED
;	IN THE REGISTER WITH THE REMAINDER STORED BACK IN THE COMMON
;	DATA AREA RAM LOCATION.  REMEMBER THAT SINCE THE COMMON DATA
;	AREA RAM IS SHARED, IF YOU ARE GOING TO USE AN ABSOLUTE LOCATION
;	THAT IS NOT YOUR <STATE> LOCATION YOU MUST USE AN INSTRUCTIONS
;	COMMAND TO MAKE SURE THE ENTIRE SEQUENCE IS COMPLETE AND YOU
;	HAVE YOUR DESIRED RESULT SAFE IN YOUR REGISTER OR STATE VARIABLE
;	BEFORE ANOTHER ENTITY CAN PROCESS.  ALSO, YOUR RESULT MUST
;	FIT INTO A SINGLE REGISTER.  YOUR FULL REGISTER IS USED FOR
;	THE DIVIDE BUT THE MAXIMUM VALUE IS H'8000 AND THE RESULT
;	MUST FIT INTO A SINGLE REGISTER.  THE HIGH BYTE IS CLEARED.
;	1 BYTE FOLLOWS THIS COMMAND:
;		1 BYTE COMMON DATA AREA BYTE TO DIVIDE BY (0-31) OR <STATE>
;72 =	<RMULTIPLY> THIS COMMAND ALLOWS YOU TO MULTIPLY YOUR REGISTER'S
;	LOW BYTE BY A VALUE IN COMMON DATA AREA RAM.  THE RESULT IS
;	RETURNED IN REGISTER (FULL WORD). IF YOU SPECIFY <STATE> ONLY
;	THE LOW BYTE OF THE STATE WORD IS USED FOR THE MULTIPLY.
;	1 BYTE FOLLOWS THIS COMMAND:
;		1 BYTE COMMON DATA AREA BYTE TO USE FOR THE MULTIPLY OR 
;		 <STATE>
;73 =	<GETHEROS> GET THE HEROS COUNT INTO THE REGISTER.	
;	1 BYTE FOLLOWS THIS COMMAND:
;		1 BYTE JOYSTICK HERO COUNT TO GET
;74 =	<SHOWSCORE> SHOW THE SCORE AT THE SPECIFIED LOCATION.  THIS
;	COMMAND ASSUMES THAT THE DIGITS 0-9 ARE AVAILABLE IN CHARACTERS
;	0-9+BASENUM (EQUATE DEFINED HERE).  IT WILL DISPLAY THE 1 WORD
;	SCORE VALUE AT THE SCREEN ROW AND COLUMN YOU SPECIFY IN THE
;	VIDEO PAGE YOU SPECIFY.  IT ONLY PUTS DOWN THE DIGITS, YOU
;	MUST HAVE THE PALETTE INFO ALREADY IN YOUR BACKGROUND.  IF
;	YOU SPECIFY A VIDEO PAGE OF <STATVID>, THIS COMMAND WILL PUT THE DATA
;	INTO YOUR STATUS LINE REGION AT THE ROW AND COLUMN SPECIFIED.
;	LEADING ZERO SUPPRESSION WILL TAKE PLACE WITH THIS COMMAND
;	BUT IT IS DONE BY PUTTING "ERASECHAR" IN PLACE OF THE ZERO
;	DIGITS.
;
;	THIS COMMAND WILL WAIT FOR THE SCREEN WRITE BUFFER TO BE AVAILABLE
;	WHICH SHOULD NORMALLY BE IMMEDIATLY BUT IT IS POSSIBLE THAT
;	YOUR EXECUTION OF THIS ENTITY'S CODE WILL SUSPEND TILL DONE.
;	4 BYTES FOLLOW THIS COMMAND:
;		1 BYTE SCORE TO DISPLAY (SEE COMMAND 37)
;		1 BYTE ROW OF VIDEO MEMORY OR STATUS LINE MEMORY
;		1 BYTE COLUMN OF VIDEO MEMORY OR STATUS LINE MEMORY
;		1 BYTE VIDEO PAGE (0 OR 1) OR <STATVID> FOR STATUS LINE MEMORY.
;
		.EQU	BASENUM,0	;BASE NUMBER FOR ASCII "0"

;75 =	<SHOWREG> SHOW THE REGISTER AT THE SPECIFIED LOCATION.  THIS
;	COMMAND ASSUMES THAT THE DIGITS 0-9 ARE AVAILABLE IN CHARACTERS
;	0-9+BASENUM (EQUATE DEFINED IN KUNGFU.ASM).  IT WILL DISPLAY THE 1 WORD
;	REGISTER VALUE AT THE SCREEN ROW AND COLUMN YOU SPECIFY IN THE
;	VIDEO PAGE YOU SPECIFY.  IT ONLY PUTS DOWN THE DIGITS, YOU
;	MUST HAVE THE PALETTE INFO ALREADY IN YOUR BACKGROUND.  IF
;	YOU SPECIFY A VIDEO PAGE OF <STATVID>, THIS COMMAND WILL PUT THE DATA
;	INTO YOUR STATUS LINE REGION AT THE ROW AND COLUMN SPECIFIED.
;	LEADING ZERO SUPPRESSION WILL TAKE PLACE WITH THIS COMMAND
;	BUT IT IS DONE BY PUTTING "ERASECHAR" IN PLACE OF THE ZERO
;	DIGITS.  THERE WILL BE 5 DIGITS MAX.
;
;	THIS COMMAND WILL WAIT FOR THE SCREEN WRITE BUFFER TO BE AVAILABLE
;	WHICH SHOULD NORMALLY BE IMMEDIATLY BUT IT IS POSSIBLE THAT
;	YOUR EXECUTION OF THIS ENTITY'S CODE WILL SUSPEND TILL DONE.
;	3 BYTES FOLLOW THIS COMMAND:
;		1 BYTE ROW OF VIDEO MEMORY OR STATUS LINE MEMORY
;		1 BYTE COLUMN OF VIDEO MEMORY OR STATUS LINE MEMORY
;		1 BYTE VIDEO PAGE (0 OR 1) OR <STATVID> FOR STATUS LINE MEMORY.
;
;76 =	<SETHEALTH> SET THIS ENTITIES HEALTH.  YOU CAN SET THIS ENTITIES
;	HEALTH TO A FIXED VALUE TO USE <REGISTER> TO USE THE REGISTER
;	CONTENTS.  YOU CANNOT SET THE HEALTH TO ZERO UNLESS YOU LOAD
;	THE REGISTER AND SPECIFY THAT.  1 BYTE FOLLOWS THIS COMMAND:
;		1 BYTE VALUE TO SET THE HEALTH TO OR <REGISTER>
;77 = 	<SOUNDBUSY> THIS COMMAND ALLOWS YOU TO BRANCH IF ONE OF THE SPECIFIED
;	SOUND CHANNELS IS STILL PLAYING.  6 BYTES FOLLOW THIS COMMAND:
;		1 WORD NEW POINTER IF THE CHANNEL IS STILL BUSY
;			1 BYTE <ON> OR <DONTCARE> TO CHECK CHANNEL 0
;			1 BYTE <ON> OR <DONTCARE> TO CHECK CHANNEL 1
;			1 BYTE <ON> OR <DONTCARE> TO CHECK CHANNEL 2
;			1 BYTE <ON> OR <DONTCARE> TO CHECK CHANNEL 3
;78 =	<REGSOUND> THIS COMMAND ALLOWS YOU TO EXECUTE COMMAND <SOUND>
;	FROM A TABLE INDEXED WITH A REGISTER.  THE TABLE MUST CONTAIN
;	AN ENTRY FOR EACH POSSIBLE REGISTER VALUE PASSED TO THIS
;	COMMAND.  EACH ENTRY MUST HAVE ALL 8 BYTES AS IN THE <SOUND>
;	COMMAND.  THE REGISTER WILL BE MULTIPLIED BY 8 AND USED
;	AS AN INDEX INTO THE TABLE TO GET THE LOCATION OF THE ACTUAL
;	MUSIC DATA.  2 BYTES FOLLOW THIS COMMAND:
;		1 WORD POINTER TO THE TABLE.
;
;	SAMPLE USAGE:		.DB	SETREG,2,0	;GET ENTRY #2
;				.DB	REGSOUND
;				.DRW	MUSICTAB
;				.DB	SKIP
;				.DRW	OVERTABLE
;	
;			MUSICTAB:	.DRW	MEL1,MEL2,MEL3,0
;					.DRW	MEL1,-1,-1,-1
;					.DRW	LOVE1,LOVE2,0,0
;
;79 =	<HIDEALL> THIS COMMAND ALLOWS YOU TO MAKE ALL OTHER ENTITIES
;	GO AWAY AS IF THEY HAD EXECUTED A DIE,0 COMMAND.  YOUR ENTITY
;	WILL NOT GO AWAY.  NO BYTES FOLLOW THIS COMMAND.
;
;7A =	<HOWMANY> THIS COMMAND ALLOWS YOU TO FIND OUT HOW MANY OF
;	A GIVEN ENTITY ARE CURRENTLY ACTIVE.  YOU SPECIFY THE ENTITY
;	NUMBER FROM ENTITYTAB AND THE QUANTITY ACTIVE AT THIS MOMENT
;	(INCLUDING SLEEPERS WAITING FOR THEIR POSITION ON SCREEN) IS
;	RETURNED IN THE REGISTER.  1 BYTE FOLLOWS THIS COMMAND:
;		1 BYTE ENTITY NUMBER OR <REGISTER> FOR THE ENTITY IN 
;		 THE REGISTER (FOR ENTITY 0, LOAD THE REGISTER WITH 0 AND
;		 SPECIFY REGISTER)
;7B =	<TESTSOLID> THIS COMMAND ALLOWS YOU TO TEST A POTENTIAL MOVEMENT
;	OF YOUR ENTITY AND SEE IF SOLID EXISTS IN THE PATH.  YOU CAN
;	ALSO USE IT TO SEE IF YOU WOULD MATERIALIZE ON SOLID IF YOU WERE
;	TO TURN SOLIDS ON AT THIS POINT BY SIMPLY SPECIFYING A MOVEMENT
;	OF 0 FOR BOTH X AND Y.  USE THIS COMMAND FOR ODD SITUATIONS NOT
;	COVERED BY THE LEDGE, PRECIPICE, STAIRS, OR FLOOR COMMANDS.
;	THE VALUE YOU SPECIFY FOR X AND Y WILL BE ADDED TO THE CURRENT
;	ENTITY POSITION AND THE BRANCH WILL BE TAKEN IF THE ENTITY
;	WOULD THUS BE PLACED OVER SOLIDS.  BE SURE THAT SOLIDSTATE IS
;	ON WHEN YOU MAKE THIS CALL SINCE IT ONLY USES YOUR CURRENT STATE.
;	4 BYTES FOLLOW THIS COMMAND:
;		1 WORD NEW EXECUTION POINTER
;		1 BYTE X OFFSET
;		1 BYTE Y OFFSET
;7C =	<WIPEOUT> THIS COMMAND WIPES THE CURRENT BACKGROUND BY FILLING
;	IT WITH "ERASECHAR" AND THEN REQUESTS THE WORLD SPECIFIED.
;	IT IS SIMILAR TO THE <WORLD> COMMAND EXCEPT THAT IT WIPES OUT
;	THE SCREEN.   IT CAN BE CALLED FROM EITHER OR HALFWAY THROUGH
;	BOTH VIDEO PAGES.  AFTER THE WIPE, ALL SOUNDS ARE STOPPED.
;	1 BYTE FOLLOWS THIS COMMAND:
;			1-254 FOR A WORLD FROM USE_BACK
;			-1 FOR THE BOOT SCREEN
;			0 <REGISTER> FOR THE ENTITIES REGISTER.
;7D =	<THROWBACK> THIS COMMAND PROVIDES A MORE RELIABLE WAY OF BEING
;	THROWN BACK BY AN ENEMIES ATTACK.  IF YOU TRY TO USE XTRACK,AWAY
;	YOU MAY BE THROWN THE WRONG DIRECTION DUE TO A CROSS OVER OF
;	CENTERLINE ON THE ATTACK.  THIS COMMAND SHOULD BE ISSUED AS SOON
;	AS POSSIBLE IN YOUR HURT CODE TO PREVENT THE ATTACKER FROM 
;	SWITCHING DIRECTIONS AND MESSING UP YOUR USAGE.  THROWBACK
;	WILL SIGN CORRECT YOUR MOMENTUM ACCORDING TO THE DIRECTION
;	THE ATTACKING ENTITY IS FACING.  IF IT IS FACING LEFT, YOUR
;	MOMENTUM WILL BE NEGATED.  Y MOMENTUM SPECIFIED HERE WILL NOT
;	BE SIGN CORRECTED, IT WILL BE APPLIED AS SPECIFIED.  2 BYTES
;	FOLLOW THIS COMMAND:
;		1 BYTE X VALUE TO SIGN CORRECT AND USE OR <REGISTER>
;		  TO USE THE REGISTER'S CONTENTS.  -1 FOR NO CHANGE.
;		1 BYTE Y VALUE TO APPLY WITHOUT SIGN CORRECTION OR
;		  <REGISTER> FOR THE REGISTER'S CONTENTS OR -1 FOR NO
;		  CHANGE.
;7E =	<GETCOLUMN>  THIS COMMAND WILL TAKE THIS ENTITIES COLUMN NUMBER
;	IN THE WORLD AND PUT IT INTO THE ENTITIES WORD REGISTER.
;7F =	<TABLEVID>  THIS COMMAND ALLOWS YOU TO WRITE A STRING OF CHARACTERS
;	FROM MEMORY INTO THE STATUS BAR AREA USING THE REGISTER TO 
;	INDEX INTO A TABLE.  IT IS THE SAME AS THE WRITEVID EXCEPT THAT
;	YOU POINT TO A TABLE OF WORDS AND THE REGISTER IS INDEXED INTO
;	THAT TABLE TO GET THE ACTUAL POINTER TO THE TABLE.  THE REGISTER
;	IS LIMITED TO 0-127.  THE LENGTH OF DATA YOU CAN WRITE IS LIMITED
;	TO 32.
;
;	6 BYTES FOLLOW THIS COMMAND:
;		1 WORD LOCATION OF TABLE.  REGISTER*2 IS USED AS AN INDEX
;		  TO PICK A WORD FROM THE TABLE.  THIS WORD IS USED JUST
;		  AS IF A WRITEVID COMMAND WERE EXECUTED.
;		1 BYTE ROW TO WRITE IT TO
;		1 BYTE COLUMN TO WRITE IT TO
;		1 BYTE VIDEO PAGE (0 OR 1) OR <STATVID> FOR STATUS BAR
;		1 BYTE LENGTH TO WRITE (32 LIMIT)
;80 =	<LIMIT> THIS COMMAND ALLOWS YOU TO EASILY LIMIT THE REGISTER'S
;	TOP VALUE.  IF THE REGISTER IS OVER THE VALUE YOU SPECIFY, IT
;	WILL BE SET TO THAT VALUE.  USE THIS PRIOR TO A TABLE ORIENTED
;	COMMAND.  2 BYTES FOLLOW THIS COMMAND:
;		1 WORD VALUE TO LIMIT THE REGISTER TO
;
;81 =	<MOVEIN> THIS COMMAND WILL ADD THE MOMENTUM YOU SPECIFY ON THE
;	SPECIFIED AXIS IN THE DIRECTION YOUR ENTITY IS FACING.  FOR
;	INSTANCE, IF YOUR ENTITY IS FACING RIGHT POSITIVE MOMENTUM IS
;	ADDED IF SOME X MOMENTUM IS SPECIFIED.  IF FACING LEFT, NEGATIVE
;	MOMENTUM WOULD BE ADDED.  USE THIS TO JUMP IN DURING AN ATTACK
;	SEQUENCE.  2 BYTES FOLLOW THIS COMMAND:
;		1 BYTE VALUE FOR THE X AXIS OR -1 FOR NONE OR <REGISTER>
;		1 BYTE VALUE FOR THE Y AXIS OR -1 FOR NONE OR <REGISTER>
;
;82 =	<NOTEQUAL> THIS COMMAND ALLOWS YOU TO COMPARE THE ENTITIES REGISTER
;	TO A VALUE AND MOVE THE EXECUTE POINTER IF THE REGISTER IS NOT EQUAL
;	TO THIS VALUE.  4 BYTES FOLLOW THIS COMMAND:
;		1 WORD NEW POINTER
;		1 WORD COMPARE VALUE

;83 =	<PALCLR> THIS COMMAND ALLOWS YOU TO OVERRIDE AN INDIVIDUAL COLOR
;	OF EITHER PALETTE.  USE THE PALETTE COMMANDS WITH -1 TO RESTORE.
;	IF YOU OVERRIDE THE COLOR OF A BLINKING PALETTE, THE NEXT BLINK
;	WILL RESTORE THE CORRECT COLOR.  USE THIS COMMAND FOR SPECIAL
;	EFFECTS THAT MUST BE COMMON TO ALL WORLDS AND CAN'T USE SPECIAL
;	PALETTES TO ACHIEVE THIS.   2 BYTES FOLLOW THIS COMMAND:
;		1 BYTE PALETTE COLOR TO EFFECT (0-15 FOR BACKGROUND,
;	          16-31 FOR SPRITE)
;		1 BYTE COLOR TO USE (0-3F).  NEVER USE 0D!
;84 =	<SETSELECT> THIS COMMAND ALLOWS YOU TO SPECIFY WHAT INTERRUPT IF
;	ANY WILL BE GENERATED BY THE SELECT BUTTON.  THE SELECT BUTTON
;	IS TIED TO A JOYSTICK.  YOU MUST HAVE TAKEN OVER A JOYSTICK TO
;	USE THIS COMMAND.  THE SELECT BUTTON CAN GENERATE ANY CONDITION
;	THAT THE <ACTIVATE> COMMAND CAN GENERATE.  THE ONLY DIFFERENCE
;	IS THAT INTERRUPTS WILL BE DISABLED WHEN THE SELECT BUTTON
;	ISSUES THE ACTIVATE.  YOU CAN SET SELECT TO GENERATE THE SAME
;	INTERRUPT AS ANOTHER JOYSTICK BUTTON IF DESIRED (SUCH AS ATTACK)
;	AND THEN LET YOUR CODE DECIDE WHAT TO DO ABOUT IT.
;	1 BYTE FOLLOWS THIS COMMAND:
;		1 BYTE <ACTIVATE> INDEX TO USE SUCH AS EDUCK, EATTACK, ETC.
;
;85 =	<CDIVIDE> THIS COMMAND ALLOWS YOU TO DIVIDE YOUR REGISTER BY
;	A CONSTANT.  THE RESULT IS RETURNED IN THE REGISTER,
;	THE REMAINDER IS DISCARDED.  THE REGISTER IS LIMITED TO 
;	H'8000 AND THE RESULT MUST BE ONE BYTE.  THE HIGH BYTE IS CLEARED.
;	1 BYTE FOLLOWS THIS COMMAND:
;		1 BYTE CONSTANT VALUE TO DIVIDE BY
;86 =	<GETJOYHEALTH> THIS COMMAND ALLOWS YOU TO FETCH THE HEALTH LEVEL
;	OF A GIVEN JOYSTICK ENTITY.  THE VALUE IS RETURNED IN YOUR
;	REGISTER, THE HIGH BYTE IS CLEARED.  1 BYTE FOLLOWS THIS COMMAND:
;		1 BYTE JOYSTICK SPECIFIER (JOY1, JOY2, OURJOY, KILLERSJOY)
;87 =	<SETJOYHEALTH> THIS COMMAND ALLOWS YOU TO SET THE HEALTH LEVEL
;	OF A GIVEN JOYSTICK ENTITY.  THE VALUE IS SET TO THE VALUE IN YOUR
;	REGISTER (LOW BYTE ONLY).  1 BYTE FOLLOWS THIS COMMAND:
;		1 BYTE JOYSTICK SPECIFIER (JOY1, JOY2, OURJOY, KILLERSJOY)
;88 = 	<ENTITYBITS> THIS COMMAND ALLOWS YOU TO CHANGE THE ENTITIES FLAG BYTE
;	WHICH IS SPECIFIED IN ENTITYTAB.  THIS IS THE BYTE THAT SPECIFIES
;	IF AN ENTITY CAN SCROLL OFF THE SCREEN, WHETHER IT TESTS WORLD COLUMN
;	COMMANDS, ETC.  YOU CAN GET THIS BYTE WITH FETCHREG, MODIFY IT, 
;	AND PUT IT BACK WITH THIS COMMAND.  1 BYTE FOLLOWS THIS COMMAND:
;		1 BYTE VALUE TO SET IT TO OR <REGISTER> TO USE THE REGISTER.
;89 =	<WORLDGOTO> ABSOLUTE PUT OF ENTITY TO AN ABSOLUTE POSITION WITHIN
;	A GIVEN WORLD.  THIS COMMAND ALLOWS YOU TO PUT YOUR ENTITY AT
;	ANY ROW AND COLUMN (8 PIXELS) WITHIN ANY WORLD.  IF THE WORLD OR
;	LEFTMOST SCREEN COLUMN CHANGES ALL ENTITIES OTHER THAN YOUR ENTITY
;	AND ANY OTHER JOYSTICK ENTITY ARE REMOVED AND THE WORLD LAUNCH FLAGS 
;	AT THE NEW POSITION ARE USED.  IF THE SCREEN LOCATION AND WORLD DO 
;	NOT CHANGE AS A RESULT  OF THIS COMMAND THE ENTITIES ARE LEFT ALONE.  
;
;	TWO PLAYER GAMES POSE A PROBLEM FOR THIS COMMAND.  YOU MUST NOT ISSUE
;	THE COMMAND UNTIL YOUR ENTITIES COME TO SOME AGREEMENT VIA SOME
;	FORM OF INTERCOMMUNCIATION.  THIS COMMAND SIMPLY DOES NOT MAKE
;	ANOTHER JOYSTICK ENTITY GO AWAY BUT THAT DOESN'T MEAN IT MIGHT
;	NOT END UP AT AN ILLEGAL POSITION IN THE NEW WORLD.  
;
;	THIS COMMAND IS REGISTER ORIENTED IN ORDER TO ALLOW YOU TO ISSUE
;	IT FROM A PARAMETER PASSED IN A WORLD COMMAND.   YOUR LOW REGISTER 
;	BYTE IS MULTIPLIED BY 7 AND ADDED TO THE OFFSET YOU GIVE.  THE RESULT 
;	IS USED AS IN INDEX INTO THE TABLE POINTED TO BY THE OFFSET.  AFTER
;	ISSUING THE COMMAND YOUR NEXT COMMAND IS EXECUTED.  REMEMBER THAT
;	THE WORLDGOTO DOES NOT STOP EXECUTION OF YOUR ENTITY, IT CONTINUES
;	TO FUNCTION IN THE NEW WORLD AT THE INSTRUCTION FOLLOWING THIS
;	COMMAND.  2 BYTES FOLLOW THIS COMMAND:
;		1 WORD POINTER TO THE TABLE OF GOTO LOCATIONS
;
;	EACH ENTRY IN THE TABLE CONSISTS OF 7 BYTES:
;		1 BYTE WORLD OR <NOCHANGE> (-1) 
;		1 BYTE SCREEN Y TEXT ROW LOCATION TO PUT THE ENTITIES TOP AT
;		  (JUST LIKE THE LAUNCH WORLD COMMANDS.
;		1 BYTE NEW TOP OF SCREEN LOCATION OR <DONTCARE> (-1) FOR
;		  FLOATING.  IF STRIP MODE, JUST USE 0.
;		1 WORD LEFTMOST SCREEN COLUMN OR <DONTCARE> (-1) FOR FLOATING
;		1 WORD SCREEN X COLUMN TO PUT THE ENTITIES LEFT AT (JUST LIKE
;		  THE LAUNCH WORLD COMMANDS).
;
;	SAMPLE USAGE:		.DB	FETCHREG,PARAM2	
;				.DB	WORLDGOTO
;				.DRW	WARPBASE	
;
;			WARPBASE:	.DB	7,3,0	    ;WORLD 7, ROW 3
;					.DRW	DONTCARE,32 ;COLUMN 32
;
;					.DB	NOCHANGE,24,0 ;CURRENT WORLD
;					.DRW	32,48	    ;COL 48 CENTERED
;8A = <REBORN> THIS COMMAND ALLOWS YOU TO RESET (ALLOW TO BE LAUNCHED)
;	ALL OR ANY OF THE PERMENENT ENTITY DEATH MEMORY BITS.  THERE ARE UP
;	TO 255 ENTITIES THAT CAN BE PERMANENTLY KEPT TRACK OF.  WHEN AN
;	ENTITY IS LAUNCHED, SETTING A NUMBER IN THE PERMANENT MEMORY INDEX
;	BYTE WILL CAUSE A CHECK OF THIS MEMORY TO BE MADE.  IF THAT ENTITY
;	HAS PREVIOUSLY DIED THEN IT WILL NOT BE LAUNCHED.  THE MEMORY IS
;	NOT AUTOMATICALLY INITIALIZED, YOU SHOULD DO THIS WITH YOUR OWN
;	LOGIC.  YOU SPECIFY SPECIFICALLY WHICH TO 0-254 ENTITY MEMORY BITS
;	YOU WANT TO RESET THUS ALLOWING THAT ENTITY TO LAUNCH IF ENCOUNTERED.
;	OR SPECIFY <ALL> FOR ALL BITS.  YOUR PROGRAM CAN DECIDE IF IT WANTS
;	TO USE THIS MEMORY FOR THE ENTIRE GAME OR JUST LEVEL BY LEVEL OR
;	IN ANY COMBINATION.  IF AN ENTITY DIES WITH THE DIE,0 COMMAND, 
;	PERMANENT MEMORY IS NOT CHANGED.  USE THIS FOR ENTITIES THAT SIMPLY
;	GO OFF SCREEN AND HAVE NOT BEEN KILLED.  USE DIE,1 TO MAKE THEM
;	PERMANENTLY DEAD.  1 BYTE FOLLOWS THIS COMMAND:
;		1 BYTE SPECIFYING PERMANENT MEMORY BIT TO RESET (0-254)
;			OR <ALL> TO RESET ALL OF THEM.
;8B = <IFNCHEAT>  IF NOT CHEAT MODE ENTRY.  THIS COMMAND WILL BRANCH IF
;	THE CURRENT WORLD WAS NOT ENTERED THROUGH CHEAT MODE.  WHEN CHEAT
;	MODE (B+SELECT) ENTERS A WORLD A FLAG IS SET.  USING THIS COMMAND
;	WILL RESET THE FLAG.  PUT YOUR CODE THAT IS VITAL TO EXECUTE
;	BELOW THIS INSTRUCTION AND BRANCH OVER IT IF ITS NOT CHEAT MODE
;	ENTERED.  2 BYTES FOLLOW THIS COMMAND:
;		1 WORD NEW EXECUTION POINT IF NOT CHEAT MODE ENTERED WORLD
;8C = <WHOSLINKED> RETURN ENTITYTAB NUMBER (ID) OF FIRST ENTITY FOUND TO
;	BE LINKED TO THIS ENTITY.  THE REGISTER IS LOADED WITH THE ID.
;	-1 IS RETURNED IF NONE.  SEE <NEXTLINKED> TO SEARCH ONWARD IN 
;	THE LINK LIST.
;8D = <GETSCORE> GET THE SCORE.  THIS COMMAND ALLOWS YOU TO GET A SCORE
;	SO YOU CAN SAVE IT OUT AS A HIGH SCORE.  1 BYTE FOLLOWS THIS COMMAND:
;		1 BYTE SCORE TO GET (SEE CMD 37)
;8E = <PUTSCORE> PUT THE SCORE.  THIS COMMAND ALLOWS YOU TO PUT THE
;	REGISTER INTO EITHER SCORE.  1 BYTE FOLLOWS THIS COMMAND.
;		1 BYTE SCORE TO PUT (SEE CMD 37)
;8F = <SWAP> THIS COMMAND WILL SWAP THE LOW AND HIGH BYTES OF THE REGISTER.
;
;90 = <PEEK> THIS COMMAND WILL LOAD YOUR REGISTER FROM A LOCATION IN MEMORY.
;	THE BYTE AT THAT LOCATION IS RETURNED IN
;	YOUR REGISTER AND THE REGISTER'S HIGH BYTE IS CLEARED.  2 BYTES
;	FOLLOW THIS COMMAND:
;		1 WORD OFFSET IN MEMORY
;
;	SAMPLE		.DB	PEEK
;			.DRW	ROMPAGE		;READS VARIABLE ROMPAGE
;91 = <POKE> THIS COMMAND WILL TAKE YOUR REGISTER'S LOW BYTE AND STORE
;	IT INTO THE MEMORY LOCATION YOU SPECIFY.  IT IGNORES THE REGISTER'S
;	HIGH BYTE.  2 BYTES FOLLOW THIS COMMAND:
;		1 WORD OFFSET IN MEMORY
;
;	SAMPLE		.DB	SETREG
;			.DRW	1      
;			.DB	POKE
;			.DRW	STATDELAY	;SET THE STATUS LINE DELAY
;						;TO THE LOWEST VALUE.
;92 = <NOTBUTTON> MOVE EXECUTE POINTER IF SPECIFIED JOYSTICK BITS ARE 
;	NOT SET.  SEE <BUTTON> FOR BITS.  IF ANY OF THE BITS ARE
;	SET THE EXECUTE POINTER WILL NOT BE MOVED. 3 BYTES FOLLOW THIS 
;	COMMAND:
;		1 WORD NEW POINTER
;		1 BYTE BITS TO BE OFF
;93 =	<ABOVECOUNT> MOVE EXECUTE POINTER IF COUNTER IS ABOVE A 
;	SPECIFIED VALUE.  SEE <COUNT> 3 BYTES FOLLOW THIS COMMAND:
;		1 WORD NEW POINTER
;		1 BYTE COUNTER VALUE TO BE ABOVE.
;94 =	<IFXEDGE> MOVE EXECUTE POINTER IF WITHIN EDGE OF SCREEN ON
;	X AXIS.  YOU DEFINE THE DISTANCE FROM THE SIDE OF THE SCREEN WHICH
;	IS CONSIDERED THE EDGE.  3 BYTES FOLLOW THIS COMMAND:
;		1 WORD NEW POINTER
;		1 BYTE DISTANCE FROM EDGE FOR CENTERLINE OF SPRITE (IN PIXELS)
;95 =	<CASE> MOVE EXECUTE POINTER IF REGISTER IS EQUAL TO A VALUE IN THE
;	CASE LIST.  THIS COMMAND ALLOWS YOU TO CHECK THE REGISTER FOR 
;	SPECIFIC AND ARBITRARY VALUES.  FOR EACH VALUE YOU PROVIDE A
;	NEW EXECUTE LOCATION.  IF THE LIST DOES NOT CONTAIN THE REGISTER'S
;	VALUE, EXECUTION IS CONTINUED FOLLOWING THIS COMMAND.  A VARIABLE
;	NUMBER OF WORDS FOLLOW THIS COMMAND:
;		1 WORD NEW EXECUTION POINT, 1 WORD REG VALUE TO MATCH
;			REPEAT FOR ALL VALUES DESIRED
;		1 WORD OF 0 TO SIGNAL END OF LIST.
;
;	SAMPLE USAGE:		.DB	FETCHREG,ENTITY	;GET THE ENTITY
;				.DB	CASE		;CATCH SPECIAL ONES
;				.DRW	MAKEFIRE,5	;IF DRAGON
;				.DRW	MAKEROCKS,32	;IF MONGOLIAN
;				.DRW	FART,44		;IF DOG
;				.DRW	0		;END OF LIST
;96 =	<EDGEMOM> THIS COMMAND ALLOWS YOU TO ADD MOMENTUM TO THE ENTITY
;	WHICH IS CORRECTED FOR THE EDGE OF THE SCREEN YOU ARE NEAREST.
;	USE POSITIVE MOMENTUM TO REPEL AWAY FROM THE NEAREST EDGE
;	AND NEGATIVE TO ATTRACT TOWARDS IT.  IT WORKS FOR BOTH THE TOP AND
;	SIDES.  USE 0 TO MAKE NO CHANGE ON A GIVEN AXIS.  THE MOMENTUM
;	IS ADDED TO YOUR CURRENT MOMENTUM AFTER CORRECTION.  2 BYTES
;	FOLLOW THIS COMMAND:
;		1 BYTE MOMENTUM TO ADD TO X AXIS
;		1 BYTE MOMENTUM TO ADD TO Y AXIS
;97 =	<ANDDATA> THIS COMMAND WILL "AND" YOUR 1 WORD VALUE TO A COMMON
;	DATA AREA LOCATION.  SINCE THE REGISTER IS 1 WORD, 2 BYTES AT THE
;	COMMON DATA AREA LOCATION ARE FETCHED UNLIKE OTHER COMMANDS. 
;	THE RESULT OF THE AND IS STORED IN THE 1 WORD REGISTER.
;		1 BYTE DATA LOCATION TO BE ANDED (0-31) OR <STATE> 
;98 =	<STATREQUEST> THIS COMMAND ALLOWS YOU TO SAVE AND HIDE THE CURRENT
;	ENTITIES AND ENTER ANOTHER WORLD.  YOU CAN THEN RETURN FROM THAT
;	WORLD AND RESTORE THE CURRENT CONDITION.  IT IS NOT A PERFECT 
;	SAVE DUE TO MEMORY CONSTRAINTS.  FOR INSTANCE, ANY WRITEVIDS YOU
;	HAVE DONE WILL NOT BE RESTORED.  ALSO, YOU NEED TO CHECK FOR
;	FREE ENTITY SLOTS BEFORE EXECUTING THIS COMMAND TO INSURE THAT
;	YOUR NEW WORLD WILL BE ABLE TO LAUNCH WHATEVER ENTITIES IT
;	NEEDS.  USE THIS COMMAND TO PUT UP A "MAP" OR MESSAGE DURING
;	WORLD PLAY.  WHILE YOU ARE IN THE OTHER WORLD, YOU MAY USE THE
;	<WORLD> COMMAND TO REQUEST OTHER WORLDS BUT YOU MAY NOT USE
;	<WORLDGOTO> OR <STATREQUEST> OR <HIDEALL>. 
;
;	ON RETURN, THE ENTITY WILL EXECUTE AT THE INSTRUCTION FOLLOWING
;	THIS COMMAND. THE PRIOR CONDITION OF YOUR WORLD WILL BE RESTORED
;	IN SO FAR AS SYSTEM VARIABLES GO BUT ANY COMMON DATA AREA RAM
;	OR STATUS BAR CHARACTERS YOUR PROGRAM USES WHICH HAVE BEEN CHANGED
;	WILL NOT BE RESTORED.  YOU MUST LAUNCH AN ENTITY TO DO THIS
;	IMMEDIATLY AFTER THIS COMMAND. 1 BYTE FOLLOWS THIS COMMAND:
;		1 BYTE WORLD TO GO TO AFTER SAVING (SAME AS THE <WORLD> CMD.
;99 =	<ENDREQUEST> THIS COMMAND WILL RETURN FROM A WORLD INVOKED WITH
;	<STATREQUEST>.  YOU MUST INSURE THAT YOU WILL ISSUE THIS COMMAND
;	EVENTUALLY OR THE STATE MACHINE WILL GET MESSED UP.  YOU CAN HOWEVER
;	REQUEST OTHER STATUS MAP WORLDS WHILE IN THE STATUS WORLD SO LONG
;	AS THE NUMBER OF ENTITIES THEY LAUNCH DOES NOT EXCEED THE AVAILABLE
;	SLOTS NOT IN USE TO SAVE THE ORIGINAL WORLD'S ENTITIES.
;9A =	<IFREQUEST> THIS COMMAND ALLOWS YOU TO SHARE A WORLD AND HAVE IT
;	BE BOTH FOR NORMAL REQUESTING AND <STATREQUEST>ING.  YOUR BRANCH
;	IS TAKEN IF WE HAVE ISSUED A STATREQUEST WITHOUT AN ENDREQUEST.
;	2 BYTES FOLLOW THIS COMMAND:
;		1 WORD NEW EXECUTE POINTER
;9B =	<USERSUB> THIS COMMAND ALLOWS YOU TO CALL A USER SUBROUTINE TO
;	DO SPECIAL TASKS SUCH AS CREATING A BACKGROUND LIST IN RAM FOR
;	USE WITH THE BACKGROUND INIT FUNCTION.  FOR INSTANCE, YOU
;	COULD PUT A BACKGROUND LIST IN STATE OR PERMANENT ENTITY MEMORY.
;	THEN YOUR BOOT SCREEN WOULD POINT TO A REAL (ROM BASED) BACKGROUND
;	LIST BUT YOUR FIRST WORLD WOULD POINT TO THE RAM BASED LIST.
;	FROM THEN ON YOU WOULD SIMPLY REQUEST WORLD 1 AND GENERATE A NEW
;	MAP WHEN YOU WANTED THE NEXT WORLD. 
;
;	YOU DO NOT NEED TO PRESERVE ANY REGISTERS IN YOUR ROUTINE.
;	INTERRUPTS MAY COME IN WHILE YOUR ROUTINE IS RUNNING, YOU
;	SHOULD NOT CODE SOMETHING THAT CARES ABOUT THAT.  USE
;	AN RTS TO RETURN.  1 WORD FOLLOWS THIS COMMAND:
;		1 WORD OFFSET OF USER SUB IN THIS ROM PAGE -1.
;
;	SAMPLE:		.DB	USERSUB
;			.DRW	MYROUTINE-1	;DON'T FORGET THE -1!!!
;
;9C =	<ROTATION> THIS COMMAND ALLOWS YOU TO TURN SPRITE ROTATION
;	ON OR OFF.  THE SPRITES ROTATE WHEN THERE ARE TOO MANY ON 
;	A LINE.  THIS TAKES PROCESSOR POWER.  IF YOU HAVE IT TURNED
;	OFF, THE EXTRA SPRITES WILL SIMPLY NOT DISPLAY.  1 BYTE
;	FOLLOWS THIS COMMAND:
;		1 BYTE <ON> OR <OFF>.
;9D =	<LOWEXEC> THIS COMMAND ALLOWS YOU TO CONTROL THE EXECUTION
;	PRIORITY BIT IN THE ENTITYTAB FLAG BITS.  THAT BIT IS IN 
;	THE THIRD BYTE, BIT H'20.  WHEN ON, THE ENTITY HAS LOW
;	PRIORITY ON EXECUTION.  IF THE STATE MACHINE GETS BEHIND
;	ON ENTITY EXECUTION THOSE WITH THIS BIT SET GET EXECUTED HALF
;	AS OFTEN AS THEY NORMALLY DO.  1 BYTE FOLLOWS THIS COMMAND:
;		1 BYTE <ON> OR <OFF>  (ON MAKES LOW EXECUTION PRIORITY).
;
;9E =	<XVIRTUAL> THIS COMMAND WILL MOVE THE EXECUTE POINTER IF AN
;	ENTITIES X LOCATION WITHIN THE LARGER VIRTUAL BACKGROUND IS LESS 
;	THAN OR EQUAL TO THE VALUE SPECIFIED.  THE CENTER OF THE ENTITY IS 
;	USED FOR THE X.  THE X POSITION NEEDS TO BE 1 WORD SINCE BACKGROUNDS
;	ARE VERY LONG.  THE VALUE IS SPECIFIED IN PIXELS.  THE LEFTMOST
;	PIXEL OF THE BACKGROUND IS 0.  4 BYTES FOLLOW THIS COMMAND:
;		1 WORD NEW EXECUTE POINTER
;		1 WORD X VALUE.
;9F =	<YVIRTUAL> THIS COMMAND WILL MOVE THE EXECUTE POINTER IF AN
;	ENTITIES Y LOCATION WITHIN THE LARGER VIRTUAL BACKGHROUND IS LESS
;	THAN OR EQUAL TO THE VALUE SPECIFIED.  VALUES WHERE YOUR ENTITY HAS
;	JUMPED ABOVE THE BACKGROUND ARE NEGATIVE AND THIS FUNCTION
;	DOES NOT ADJUST FOR THIS.   THE Y VIRTUAL LOCATION IS CONSIDERED
;	TO BE THE ENTITIES FEET SO IF YOUR ENTITY CANNOT JUMP SO HIGH THAT
;	HIS BOTTOM PIXEL ROW GOES ABOVE THE SCREEN (RECOMMENDED) YOU WON'T
;	HAVE NEGATIVE VALUES TROUBLES.   TRY SETTING THE WRAP PREVENTION
;	BIT IN THE ENTITY FLAGS TO EASE CHECKING. THE VALUE IS SPECIFIED
;	IN PIXELS AND SINCE THE VIRTUAL BACKGROUNDS CAN BE UP TO 
;	1920 PIXELS HIGH 1 FULL WORD IS NEEDED FOR THE PIXEL LOCATION.
;	THE TOPMOST PIXEL OF THE BACKGROUND IS 0. 4 BYTES FOLLOW THIS COMMAND:
;		1 WORD NEW EXECUTE POINTER
;		1 WORD Y VALUE.

;A0 =	<BVIRTUAL> THIS COMMAND WILL MOVE THE EXECUTE POINTER IF AN
;	ENTITIES Y LOCATION WITHIN THE LARGER VIRTUAL BACKGHROUND IS LESS THAN
;	OR EQUAL TO THE NUMBER OF PIXELS YOU SPECIFY FROM THE BOTTOM OF 
;	THE BACKGROUND. ITS LIKE YVIRTUAL EXCEPT THAT ITS ADAPTED SO THAT 
;	YOU CAN USE THE BOTTOM OF THE SCREEN AS PIXEL 0 INSTEAD OF THE TOP.  
;	THIS IS COMMONLY NEEDED.  THUS YOU CAN THINK OF THIS COMMAND
;	AS NUMBERING FROM THE BOTTOM INSTEAD OF THE TOP BUT OTHERWISE
;	THE SAME AS <YVIRUTAL>. 4 BYTES FOLLOW THIS COMMAND:
;		1 WORD NEW EXECUTE POINTER
;		1 WORD Y VALUE
;
;A1 =	<BLOAD> THIS COMMAND WILL LOAD A BYTE FROM THE COMMON DATA
;	AREA INTO THE ENTITIES REGISTER WITHOUT ZEROING THE HIGH REGISTER.
;
;	1 BYTE FOLLOWS THIS COMMAND:
;		1 BYTE DATA TO BE FETCHED (0-31).  <STATE> IS ILLEGAL.
;A2 =   <LINKMOM> SET MOMENTUM TO MATCH THAT OF THE ENTITY TO WHOM YOU
;	ARE LINKED.  NO BYTES FOLLOW.
;A3 = 	<DISTANCE> MOVE EXECUTE POINTER IF TARGET IS WITHIN SPECIFIED
;	DISTANCE (LESS THAN DISTANCE).  IT DOES NOT MATTER WHICH DIRECTION
;	YOUR ENTITY IS FACING OR IF IT IS MOVING.  THE ENTITIES CENTERLINES 
;	ARE USED FOR THE X, THE BOTTOM PIXEL ROW (ITS FOOT) IS USED FOR THE Y.
;	THIS COMMAND IS FOLLOWED BY 4 BYTES:
;	   	1 WORD NEW POINTER (USED IF TEST PASSES)
;	   	1 BYTE X RANGE IN PIXELS (USE -1 FOR DON'T CARE)
;	   	1 BYTE Y RANGE IN PIXELS (USE -1 FOR DON'T CARE)
;A4 =	<LINKFACE> THIS COMMAND ALLOWS YOU TO FORCE YOUR LINKED ENTITY
;	TO HONOR ITS <FACE> SPECIFICATION.  NOTE THAT IF YOUR FACE
;	SPECIFICATION REQUIRES FACING THE DIRECTION OF TRAVEL, THIS
;	IS THE DIRECTION OF MOMENTUM AND YOU SHOULD PUT
;	A <LINKMOM> COMMAND IS A LOOP WHILE IT IS LINKED IF YOU WANT
;	TO FACE THE WAY THE ONE TO WHICH IT IS LINKED IS TRAVELING.
;	ALSO, THE RELATIVE LINK CALCULATIONS ARE CORRECTED FOR THE
;	DIRECTION THE ENTITY TO WHOM YOU ARE LINKED IS FACING REGARDLESS
;	OF WHETHER YOU USE THIS COMMAND.   THE BEST USE OF THIS
;	COMMAND IS TO MAKE YOUR ENTITY FACE UPSIDE DOWN WHILE LINKED.
;	ANY OTHER USE IS UP IN THE AIR.
;	1 BYTE FOLLOWS THIS COMMAND:
;		1 BYTE <ON> OR <OFF>.  ON MEANS IT USES <FACE> VALUE. 
;A5 =	<READCHAR> THIS COMMAND ALLOWS YOU TO READ THE BACKGROUND CHARACTER
;	UNDER YOUR SRITE.  YOU SPECIFY THE X AND Y DISPLACEMENT FROM
;	THE TOP LEFT OF THE SPRITE.  THE CHARACTER UNDER THAT POSITION IS
;	RETURNED IN THE LOW BYTE OF YOUR REGISTER AND THE HIGH BYTE IS
;	CLEARED.  NEGATIVE VALUES ARE SUBTRACTED FROM YOUR CURRENT LOCATION
;	BUT IT WRAPS AT 0 BYTEWISE.  YOUR REGISTER'S LOW BYTE IS USED 
;	FOR THE X AND THE REGISTER'S HIGH BYTE IS USED FOR THE Y.
;A6 =	<REGLAUNCH> RELATIVE LAUNCH OF AN ENTITY USING THE REGISTER.  
;	USE THIS COMMAND TO LAUNCH AN ENTITY 
;	THROW BULLETS, BOMBS, OR FOR SPECIAL STRUCTURES COMPRISED OF 
;	MULTIPLE ENTITIES SUCH AS WHIPS.  THE LOW BYTE OF YOUR REGISTER
;	IS ASSUMED TO CONTAIN THE X OFFSET AND THE HIGH THE Y.  THESE
;	ARE USED THE SAME AS FOR THE LAUNCH COMMAND.  2 BYTES FOLLOW 
;	THIS COMMAND:
;		1 BYTE ENTITY NUMBER TO LAUNCH.  
;		1 BYTE VALUE TO PLACE INTO PARAM2 OF THAT ENTITY.
;A7 =	<WHOSTHERE> SEE IF ENTITY EXISTS AT POINT RELATIVE TO YOUR ENTITY.
;	THIS COMMAND ADDS YOUR LOW REGISTER TO YOUR ENTITIES X OFFSET ON
;	VISUAL SCREEN AND THE HIGH REGISTER TO ITS Y OFFSET.  IT THEN
;	RETURNS THE FIRST ENTITY IT FINDS AT THAT SPOT ON SCREEN OR
;	A FULL WORD OF -1 IF NONE.  THE ENTITY NUMBER RETURNED IS
;	A FULL WORD OF THE ENTITY NUMBER FROM ENTITYTAB.  
;	AN ENTITY IS CONSIDERED TO BE AT THAT POINT IF IT IS WITHIN
;	8 PIXELS OF THE POINT YOU SPECIFY EVEN IF THAT POINT IS NOT
;	TOUCHING THE ENTITY.  IF THE POINT TOUCHES THE ENTITY, ITS
;	COUNTED AS THERE NO MATTER HOW FAR AWAY THE BORDER IS.
;	NO BYTES FOLLOW THIS COMMAND.
;A8 =	<ALIGNXY> THIS COMMAND WILL TAKE AN X SCREEN OFFSET IN THE
;	LOW BYTE OF YOUR REGISTER, A Y IN THE HIGH, AND WILL ADJUST
;	BOTH TO BE ON THE UPPER LEFT PIXEL OF THAT SCREEN ROW AND 
;	COLUMN.  USE THIS TO EXACTLY ALIGN REGLAUNCH OVER A SCREEN
;	ROW AND COLUMN REGARDLESS OF THE SCREEN'S ODD PIXEL SHIFT.
;	NO BYTES FOLLOW THIS COMMAND.
;A9 =	<MOVEOVER> THIS COMMAND ALLOWS YOU TO MOVE YOUR SPRITE WITHOUT
;	HAVING TO RELY ON MOMENTUM AND FIXED TIMING.  YOU SPECIFY
;	THE AMOUNT TO MOVE ON THE X AND Y (SIGNED VALUE).  2 BYTES
;	FOLLOW THIS COMMAND:
;		1 BYTE X DISPLACEMENT
;		1 BYTE Y DISPLACEMENT
;			OR
;		1 FULL WORD OF <REGISTER> TO USE LOW REG FOR X AND
;			HIGH REG FOR Y.
;AA =	<CHARSET> SELECT THE CHARACTER SET TO USE FOR THE WORLD.  YOU
;	CANNOT SELECT CHARACTER SET 0 DIRECTLY WITH THIS COMMAND, YOU HAVE
;	TO LOAD THE REGISTER WITH 0 AND SPECIFY <REGISTER> 
;	YOU CAN ALSO SPECIFY -1 TO RESTORE THE ORIGINAL SET FOR THIS 
;	WORLD.  1 BYTE FOLLOWS THIS COMMAND:
;		1 BYTE CHARSET TO USE <REGISTER> OR -1 TO RESTORE THE ORIGINAL.
;AB =	<TEXTWRITE>  THIS COMMAND ALLOWS YOU TO PUT A BLOCK OF TEXT INTO
;	VIDEO.  THE BLOCK CAN CONTAIN EMBEDDED CURSOR ADDRESSING INFO.
;	THE "CURSOR" IS INTERNAL TO THE STATE MACHINE AND WILL REMAIN INTACT
;	FOR CONTINUED LOOPS IN YOUR CODE SO LONG AS NO OTHER ENTITY TRIES
;	TO USE IT. 1 WORD FOLLOWS THIS COMMAND:
;		1 WORD POINTER TO THE BLOCK OF DATA TO WRITE OR 
;		  <REGISTER> TO USE THE REGISTER AS THE ADDRESS.
;	THE BLOCK OF DATA TO WRITE HAS THE FOLLOWING FORMAT:
;		0 = END OF BLOCK
;		-1 = ABSOLUTE VIDEO BUFFER ADDRESS FOLLOWS:
;			1 WORD BUFFER ADDRESS:
;				2000H = ROW 0, COL 0 OF VIDEO 0
;				2001H = ROW 0, COL 1 OF VIDEO 0
;				2030H = ROW 1, COLUMN 16 OF VIDEO 0.
;				2400H = ROW 0, COL 0 OF VIDEO 1.
;		-2 = ADD TO ROW AND COLUMN.  1 WORD FOLLOWS:
;			1 WORD AMOUNT TO ADD TO CURRENT ADDRESS
;
;
;		    EXAMPLE:	.DB	-1,3,2	;ROW 3, COLUMN 2, VIDEO 0
;				.DB	"HI THERE"	;PRINT HI THERE
;				.DB	-2,1,0	;SKIP DOWN 1 ROW
;				.DB	"!"
;				.DB	0	;END
;
;AC =	<REGLOAD>  THIS COMMAND USES THE VALUE IN THE HIGH BYTE OF YOUR
;	REGISTER TO DECIDE WHERE TO FETCH A BYTE FROM COMMON DATA AREA
;	RAM.  THE LOW BYTE OF YOUR REGISTER IS LOADED WITH IT AND 
;	THE HIGH BYTE IS UNCHANGED.
;AD =	<REGSTORE>  THIS COMMAND STORES THE LOW BYTE OF YOUR REGISTER
;	INTO THE COMMON DATA AREA RAM BYTE LOCATION SPECIFIED IN THE
;	HIGH BYTE OF YOUR REGISTER.  THE REGISTER IS UNCHANGED.
;AE =	<WAKEUP> THIS COMMAND ALLOWS YOU TO WAKE UP AN ENTITY THAT
;	WAS PUT TO SLEEP AS THE RESULT OF A STATREQUEST COMMAND.
;	3 BYTES FOLLOW THIS COMMAND:
;		1 BYTE IDENTIFICATION TYPE OF THE ENTITY (<COLUMN> OR <ID>).
;		1 WORD NUMBER TO MATCH.  
;
;		NOTE: SEE COMMAND <ACTIVE> FOR MEANING OF EACH. 
;AF =	<STATINFO> THIS COMMAND ALLOWS YOU TO OBTAIN INFORMATION ABOUT
;	THE WORLD YOUR STATREQUESTed WORLD CAME FROM.  FOR INSTANCE, YOU
;	MIGHT NEED TO KNOW WHAT CHARACTER SET IT USED SO YOU CAN CHANGE
;	TO THAT SET.  OR YOU MIGHT WANT TO KNOW THE WORLD NUMBER SO YOU
;	CAN <TABLE> ON IT.  WITHOUT THIS COMMAND YOU WOULD HAVE TO STUFF
;	THAT INFO INTO A COMMON DATA AREA RAM LOCATION.  THE INFO YOU
;	REQUEST WITH THIS COMMAND IS PUT INTO YOUR WORD REGISTER.  1 BYTE
;	FOLLOWS THIS COMMAND:
;			1 BYTE INFO TO FETCH:
;				<WORLD>=WORLD NUMBER
;				<CHARSET>=CHARACTER SET
;				<BPALETTE>=BACKGROUND PALETTE
;				<SPALETTE>=SPRITE PALETTE
;	
;B0 =	<NEXTLINKED> THIS COMMAND RETURNS THE NEXT ENTITY THAT IS LINKED
;	TO YOU FOLLOWING A <WHOSLINKED> CALL.  THERE IS ONLY A SINGLE
;	INTERNAL VALUE TO POINT TO THE NEXT IN THE LIST AND THUS YOU
;	MUST USE AN INSTRUCTIONS COMMAND TO INSURE YOUR ENTITY IS THE
;	ONLY ONE EXECUTING BETWEEN THE <WHOSLINKED> AND THE FINAL
;	<NEXTLINKED> COMMAND.  IF YOU LET EXECUTION END THIS COMMAND MAY BE
;	INVALID.  THE RETURN FOR THIS COMMAND IS THE SAME AS <WHOSLINKED>
;	EXCEPT THAT THE LAST ENTITY RETURNED IS SKIPPED.  EVENTUALLY
;	-1 WILL BE RETURNED.  
;B1 =	<TRANSLATE> THIS COMMAND ALLOWS YOU TO TRANSLATE YOUR REGISTER'S
;	VALUE FROM A LIST OF VALUES.  IF YOUR REGISTER MATCHES ONE OF THE
;	ENTRIES IT IS TRANSLATED INTO THE SPECIFIED ENTRY.  OTHERWISE THE
;	REGISTER IS CHANGED TO -1.  A VARIABLE NUMBER BYTES FOLLOWS THIS
;	COMMAND:
;		1 WORD VALUE TO MATCH, 1 WORD TO TRANSLATE TO
;			REPEAT FOR ALL VALUES DESIRED
;		1 WORD OF 0 TO SIGNAL END OF LIST.
;
;B2 =	<PRESERVE> THIS COMMAND IS USED TO TURN THE PRESERVE BIT IN
;	THE 3RD ENTITYTAB FLAG BYTES ON OR OFF.  WHEN ON, IF A WORLDGOTO
;	IS ISSUED BY ANOTHER ENTITY FOR THIS WORLD YOUR ENTITY WILL NOT
;	BE REMOVED.  ITS GOOD FOR CASES LIKE SOMETHING THAT A HERO CARRIES
;	VIA THE <LINK> COMMAND.  WHEN THE HERO GOES INTO A DOOR IT ISN'T
;	GOOD FOR THE THING TO GO AWAY.  IF THE WORLD CHANGES THE
;	PRESERVE BIT HAS NO EFFECT, THE ENTITY WILL BE REMOVED UNLESS IT
;	IS A JOYSTICK ENTITY.  1 BYTE FOLLOWS THIS COMMAND:
;		1 BYTE <ON> OR <OFF>
;
;B3 =	<REGNOISE> THIS COMMAND ALLOWS YOU TO EXECUTE COMMAND <LOWNOISE>
;	FROM A TABLE INDEXED WITH A REGISTER.  THE TABLE MUST CONTAIN
;	AN ENTRY FOR EACH POSSIBLE REGISTER VALUE PASSED TO THIS
;	COMMAND.  EACH ENTRY HAS THE SAME WORD USED WITH LOWNOISE.
;	THE REGISTER WILL BE MULTIPLIED BY 2 AND USED 
;	AS AN INDEX INTO THE TABLE TO GET THE LOCATION OF THE ACTUAL
;	LOWNOISE DATA.  2 BYTES FOLLOW THIS COMMAND:
;		1 WORD POINTER TO THE TABLE.
;
;	SAMPLE USAGE:		.DB	LOAD,STATE	;GET THE LOWNOISE
;				.DB	REGNOISE
;				.DRW	NOISETAB
;				.DB	SKIP
;				.DRW	OVERTABLE
;
;			NOISETAB:	.DRW	MOO
;					.DRW	BARK
;					.DRW	FART
;
;B4 =	<REVMOM> REVERSE MOMENTUM.  THIS COMMAND ALLOWS YOU TO REVERSE
;	THE MOMENTUM ON EITHER AXIS.  2 BYTES FOLLOW:
;		1 BYTE <CHANGE> OR <NOCHANGE> FOR X AXIS
;		1 BYTE <CHANGE> OR <NOCHANGE> FOR Y AXIS
;B5 =	<GETROW>  THIS COMMAND WILL TAKE THIS ENTITIES ROW NUMBER
;	IN THE WORLD AND PUT IT INTO THE ENTITIES WORD REGISTER.
;B6 =	<STACK> THIS COMMAND FUNCTIONS EXACTLY THE SAME AS <LINK> EXCEPT
;	THAT THE ENTITY TO WHICH YOU WILL LINK IS THE LAST ONE THAT WAS
;	<STACK>ed ONTO THE ENTITY YOU SPECIFY.  WHEN YOU WANT TO UNLINK,
;	USE THE CORRESPONDING <UNSTACK> COMMAND.  THERE IS ALSO A COMMAND
;	TO ROTATE THE STACK WHICH CAUSES THE ONE ON THE BOTTOM (FIRST IN
;	LINK CHAIN) TO BE PLACED AS LAST IN THE CHAIN. 	
;	5 BYTES FOLLOW THIS COMMAND:
;		1 BYTE OFFSET RELATIVE TO ITS X.  -1 FOR THE CURRENT OFFSET
;		1 BYTE OFFSET RELATIVE TO ITS Y.  -1 FOR THE CURRENT OFFSET
;		1 BYTE IDENTIFICATION TYPE OF THE ENTITY (<COLUMN> OR <ID>).
;			YOU CAN SPECIFY <ATTACKER> FOR THE LAST ATTACKER
;			AGAINST THIS ENTITY (THEN THE WORD AFTERWARDS IS
;			NOT USED BUT MUST BE PRESENT).
;		1 WORD NUMBER TO MATCH.  IF FROM ENTITYTAB, ONLY LOW BYTE
;		  IS USED.  IF WORLD COLUMN, FULL WORD.  YOU CAN ALSO SPECIFY
;		  <REGISTER> FOR THE VALUE IN THE REGISTER (ONLY PROVIDES
;		  1 BYTE RANGE, TOP BYTE IS ZEROED). THIS MEANS YOU CAN'T 
;		  MATCH 0 UNLESS YOU LOAD THE REGISTER WITH 0.
;
;	WHILE STACKED, USE THE FOLLOWING COMMANDS AS IF YOU WERE LINKED:
;		<RELINK>, <IFLINKED>
;B7 =	<UNSTACK>  THIS COMMAND CAUSES AN ENTITY WHICH WAS PLACED INTO
;	A LINK CHAIN WITH THE <STACK> COMMAND TO UNLINK.  IF THE SPRITE
;	IS NOT ON THE END OF THE STACK, THE STACK WILL BE ADJUSTED.
;B8 =	<TOPSTACK>  THIS COMMAND ALLOWS AN ENTITY IN A STACK
;	TO MOVE ITSELF TO LAST IN THE STACK LIST.  BECAUSE ENTITIES MAY
;	HAVE ENTITIES LINKED TO THEM OR CHAINED TO THEM, THE CONTROLLING
;	ENTITY CANNOT ISSUE THIS COMMAND.  IT MUST BE ISSUED BY AN ENTITY
;	IN THE CHAIN.  TYPICALLY YOUR CONTROLLING ENTITY (FOR EXAMPLE
;	A HERO CARRYING A STACK) CAN FIND THE FIRST WITH <WHOSLINKED>
;	AND THEN ISSUE A SPECIAL HURT TO THAT ONE.  THIS HURT COULD
;	CAUSE THAT ENTITY TO ISSUE THIS COMMAND.  <TOPSTACK> IS OK TO 
;	ISSUE EVEN IF THE STACK IS JUST 1 DEEP.  NO BYTES FOLLOW THIS 
;	COMMAND.
;B9 = 	<UNIDENTIFY> THIS COMMAND ALLOWS YOU TO RESET A SPECIFIC IDENTIFY
;	BIT WITHOUT CHANGING THE OTHERS.  IDENTIFY IS A REPLACEMENT, THIS
;	ONE TURNS OFF THE SPECIFIED BITS (EVEN IF THEY WERE ALREADY OFF).
;	1 WORD FOLLOWS THIS COMMAND:
;		1 WORD IDENTIFICATION LEVEL BITS TO TURN OFF
;
;BA =	<ADDIDENTIFY> THIS COMMAND IS THE OPPOSITE OF <UNIDENTIFY> AND
;	WILL TURN ON SPECIFIC BITS WITHOUT CHANING THE OTHERS.
;	1 WORD FOLLOWS THIS COMMAND:
;		1 WORD IDENTIFICATION LEVEL BITS TO TURN ON
;BB =	<NOTSTANDING> MOVE EXECUTE POINTER IF NOT IN CONTACT WITH SOLID.
;	2 BYTES FOLLOW THIS COMMAND:
;		1 WORD NEW POINTER
;BC =	<STACKHURT> THIS COMMAND ALLOWS YOU TO COMMUNICATE WITH ENTITIES
;	STACKED TO YOUR ENTITY.  YOU SPECIFY THE DEPTH IN THE STACK TO
;	HURT AND THE STACK CHAIN IS FOLLOWED UNTIL THAT DEPTH IS FOUND.
;	IF YOU SPECIFY TOO DEEP, NO ENTITY WILL BE HURT BUT IT WILL NOT
;	CAUSE ANY TROUBLE.  NOTE THAT ALL STACK FUNCTIONS HAVE PROBLEMS
;	IF YOU ALSO <LINK> TO THAT ENTITY.  THE STACK SEARCH ONLY STARTS
;	WITH THE FIRST LINKED ENTITY FOUND.  YOU CAN ALSO USE THIS
;	COMMAND TO LIMIT A STACK HEIGHT BY ISSUING A SPECIAL HURT TO
;	DROP ANYTHING ABOVE THE LEGAL HEIGHT.
;	4 BYTES FOLLOW THIS COMMAND:
;		1 BYTE DAMAGE FLAG #3 TO USE, SAME AS IN ANIMATION 
;			TABLE DEFINITION
;		1 BYTE STACK DEPTH TO USE (1-???)
;BD =	<STACKWAKE> THIS COMMAND ALLOWS YOU TO WAKE UP AN ENTITY THAT
;	WAS PUT TO SLEEP AS THE RESULT OF A STATREQUEST COMMAND AND
;	IS STACKED TO YOUR ENTITY.  YOU SPECIFY THE STACK DEPTH.  
;	1 BYTE FOLLOWS THIS COMMAND:
;		1 BYTE STACK DEPTH TO USE (1-???)
;BE =	<STATSLEEP> THIS COMMAND ALLOWS AN ENTITY THAT WAS AWAKENED WITH
;	<WAKEUP> OR <STACKWAKE> TO PUT ITSELF BACK TO THE SLEEP CONDITION.
;BF =	<RAMWRITE> THIS COMMAND IS THE SAME AS <TEXTWRITE> EXCEPT THAT
;	IT CAN BE USED TO FETCH DATA FROM LOW MEMORY (IE., RAM).
;	NOTE THAT TEXT DATA CAN NOT BE IN CODE PAGE 1 (MEMORY.SEG).
;	IT CAN ONLY BE IN CODE PAGE 0 (CODE.SEG)
;		1 WORD POINTER TO THE BLOCK OF DATA TO WRITE OR 
;		  <REGISTER> TO USE THE REGISTER AS THE ADDRESS.
;C0 =	<OR> OR REGISTER WITH FIXED VALUE.  2 BYTES FOLLOW THIS COMMAND:
;		1 WORD VALUE TO OR TO THE REGISTER.
;C1 =	<ORDATA> THIS COMMAND ALLOWS YOU TO OR THE REGISTER TO
;	A BYTE FROM THE COMMON DATA AREA.  THE RESULT IS STORED IN
;	THE REGISTER. ONLY A BYTE IS ORED FROM THE COMMON DATA AREA RAM UNLESS
;	YOU SPECIFY <STATE> AS THE COMMON DATA AREA RAM.
;	1 BYTE FOLLOWS THIS COMMAND:
;		1 BYTE DATA LOCATION TO BE ORED (0-31) OR <STATE> 
;C2 =	<IFVIRT> THIS COMMAND WILL BRANCH IF THE ENTITY WAS AWAKENED FROM
;	BEING VIRTUALIZED.   A NORMAL WAKEUP FROM BEING LAUNCHED WILL
;	NOT CAUSE A BRANCH.  
;
;	WHEN AN ENTITY SCROLLS OFF SCREEN VERTICALLY OR IF YOU HAVE SET
;	THE VIRTUALIZE BIT IN THE ENTITYTAB FLAGS AND THE ENTITY SCROLLS
;	OFF SCREEN HORIZONTALLY, IT IS PRESERVED IN THE "VIRTUAL" STATE.
;	IF IT SCROLLS BACK ON VERTICALLY, OR IF IT SCROLLS BACK ON 
;	HORIZONTALLY, IT WILL BE "RE-AWAKENED".  THIS MEANS THAT IT WILL
;	HAVE ITS OLD POSITION FROM WHEN IT WAS SCROLLED OFF BUT IT WILL
;	NOT CONTINUE EXECUTION AT ITS OLD CODE LOCATION.  INSTEAD THE
;	WAKEUP IS CALLED (DUE TO INTERNAL RAM LIMITATIONS).
;
;	NOTE THAT HORIZONTALLY VIRTUALIZED ENTITIES ONLY STAY VIRTUALIZED
;	FOR 16 COLUMNS OFF SCREEN.  VERTICALLY VIRTUALIZED ONES STAY
;	VIRTUALIZED SO LONG AS THE ARE WITHIN 16 COLUMN ON SCREEN REGARDLESS
;	OF HOW FAR FROM SCREEN THEY ARE VERTICALLY.
;
;	THE VIRTUALIZED WAKEUP BIT STAYS SET PERMANENTLY AND IS NOT RESET
;	BY THIS COMMAND.  IT IS ONLY RESET IF THE ENTITY IS REMOVED AND
;	RELAUNCHED.  1 WORD FOLLOWS THIS COMMAND:

;		1 WORD NEW EXECUTION POINT IF VIRTUALIZED WAKEUP.
;C3 =	<SHOWPOS>  THIS COMMAND FORCES THE SPRITES ACTUAL VIEWABLE POSITION
;	ON SCREEN TO BE UPDATED REGARDLESS OF WHETHER THE ENTITY IS STUCK
;	IN AN EXECUTION LOOP. 
;
;	SOMETIMES IT IS DESIRABLE TO LOCK UP GAME EXECUTION WITH AN
;	INSTRUCTIONS LOOP.  THIS KEEPS ALL OTHER ENTITIES FROM DOING
;	ANYTHING WHILE SOME TYPE OF BONUS AWARD OR OTHER EVENT IS TAKING
;	PLACE.  WHILE IN THE LOOP, YOU CAN USE MOVEOVER OR GOTO TO PUT
;	THE EXECUTING ENTITY AT A DIFFERENT PLACE ON SCREEN.  BUT THE 
;	ACTUAL VISUAL UPDATE OF THE SPRITE DOESN'T TAKE PLACE UNTIL
;	ALL SPRITES HAVE FINISHED EXECUTING.  THIS WILL NEVER HAPPEN IN
;	AN INSTRUCTIONS LOOP.  USING THIS COMMAND YOU CAN FORCE THE
;	VISUAL UPDATE.  
;
;	REMEMBER THAT WHEN LOCKING UP EXECUTION DON'T TRY TO USE A MOMENTUM
;	COMMAND TO MOVE YOUR SPRITE SINCE THE MOMENTUM IS NOT APPLIED UNTIL
;	AFTER EXECUTION ENDS.  NO BYTES FOLLOW THIS COMMAND.

;

